Namespaces
namespace	detail

namespace	io_detail

Classes
struct	AimDataT
	Aim constraint data: a local ray (point, dir) passes a global point target. More...

class	AimDirErrorFunctionT
	The AimDirErrorFunction computes the element-wise differences between the normalized aim vector and the ray direction. More...

class	AimDistErrorFunctionT
	The AimDistErrorFunction computes the distance from the aim target point to an aim ray (an original and a positive direction). More...

class	AlignedAllocator
	An allocator that aligns memory blocks according to a specified alignment. More...

struct	AlignedDeleter
	Custom deleter for aligned memory. More...

struct	BaseConfig
	Common configuration for a tracking problem. More...

struct	BlendShape
	Skinning class that combines blend shape vectors with a base shape. More...

struct	BlendShapeBase
	Skinning class that manages blend shape vectors/offsets. More...

struct	BlendWeightsT

struct	BoneWeightT

struct	CalibrationConfig
	Configuration for running body and/or locator calibration. More...

struct	CharacterParametersT
	A struct that encapsulates both pose and identity parameters for a character. More...

struct	CharacterStateT
	Represents the complete state of a character at a specific point in time. More...

struct	CharacterT
	A character model with skeletal structure, mesh, and optional components. More...

class	CollisionErrorFunctionStatelessT
	NOTE: This is a resurrected version of the `CollisionErrorFunction` (previously updated by D50818775). More...

class	CollisionErrorFunctionT

struct	CollisionGeometryStateT
	Represents collision geometry states using a Structure of Arrays (SoA) format. More...

class	ColumnIndexedMatrix

struct	ConstraintData
	Base structure of constraint data. More...

class	ConstraintErrorFunctionT
	The ConstraintErrorFunction is a base class of a general form of constraint errors l = w * loss(f^2), where w is the weight (could be a product of different weighting terms), loss() is the generalized loss function (see math/generalized_loss.h), and f is a difference vector we want to minimize. More...

struct	DeduceSpanType
	A utility struct that facilitates the deduction of a `std::span` type from a given type. More...

struct	DistanceConstraintDataT

class	DistanceErrorFunctionT

struct	EigenStrongType

struct	ErrorFunctionDerivativesT

struct	FbxCoordSystemInfo
	A struct containing the up, front vectors and coordinate system for FBX export. More...

struct	FileSaveOptions
	Unified options for saving files in both FBX and GLTF formats. More...

class	FixedAxisAngleErrorFunctionT
	Angle: compute the angle between the two axis using acosine of their dot product. More...

class	FixedAxisCosErrorFunctionT
	Cos: compute the dot product between the two axis - cosine of the angle between them. More...

struct	FixedAxisDataT
	Axis constraint data. More...

class	FixedAxisDiffErrorFunctionT
	Diff: compute the element wise differences between the two axis. More...

class	FullyDifferentiableDistanceErrorFunctionT

class	FullyDifferentiableMotionErrorFunctionT

class	FullyDifferentiableOrientationErrorFunctionT

class	FullyDifferentiablePosePriorErrorFunctionT

class	FullyDifferentiablePositionErrorFunctionT

class	FullyDifferentiableProjectionErrorFunctionT

class	FullyDifferentiableSkeletonErrorFunctionT

class	FullyDifferentiableStateErrorFunctionT

struct	GaussNewtonSolverOptions
	Extended options specific to the Gauss-Newton optimization algorithm. More...

struct	GaussNewtonSolverQROptions
	Gauss-Newton solver with QR decomposition specific options. More...

class	GaussNewtonSolverQRT

class	GaussNewtonSolverT
	Implementation of the Gauss-Newton optimization algorithm. More...

class	GeneralizedLossT
	Implementation of "A General and Adaptive Robust Loss Function" (https://arxiv.org/abs/1701.03077). More...

class	GltfBuilder
	Helper class to build a glb scene. More...

struct	GradientDescentSolverOptions
	Extended options for the Gradient Descent optimization algorithm. More...

class	GradientDescentSolverT
	First-order optimization algorithm that follows the negative gradient. More...

class	HeightErrorFunctionT
	Error function for character height constraints. More...

struct	InverseParameterTransformT

struct	IOOptions

struct	ispanstream
	istream that takes a span of const bytes as input. More...

struct	JointParametersT

struct	JointStateT
	Represents the state of a joint with local and global transformations. More...

struct	JointT
	A simplified version of a Maya joint with pre-rotation only (no post-rotation). More...

struct	JointToJointDistanceConstraintT
	Constraint that enforces a distance relationship between two points attached to different joints. More...

class	JointToJointDistanceErrorFunctionT
	Error function that penalizes deviation from a target distance between two points attached to different joints. More...

union	LimitData

struct	LimitEllipsoid

class	LimitErrorFunctionT

struct	LimitHalfPlane
	Constraint: (p1, p2) · (normal) - offset >= 0. More...

struct	LimitLinear
	Linear relationship between parameters: p_0 = s * p_1 - o. More...

struct	LimitLinearJoint

struct	LimitMinMax

struct	LimitMinMaxJoint

struct	Locator
	Represents a point attached to a joint in a skeleton. More...

struct	LocatorState
	Tracks the current world positions of locators in a skeleton. More...

class	LowRankCovarianceMatrixT

struct	Marker
	Marker represents a motion capture marker that defines an active marker during motion capture. More...

struct	MarkerSequence
	MarkerSequence stores all the frames from a single capture sequence for one subject (motion capture actor). More...

struct	MeshStateT
	Represents the complete state of a model's mesh. More...

struct	MeshT
	A generic mesh representation with support for vertices, faces, lines, and texture coordinates. More...

struct	ModelOptions

class	ModelParametersErrorFunctionT

class	ModelParametersSequenceErrorFunctionT

struct	ModelParametersT

struct	MppcaT
	Mixture of Probabilistic Principal Component Analysis (MPPCA) Based on: http://www.miketipping.com/papers/met-mppca.pdf. More...

class	MultiposeSolverFunctionT

struct	MultiposeSolverOptions
	Multipose solver specific options. More...

class	MultiposeSolverT

struct	NormalDataT
	Normal constraint data: data needed to compute the point-to-plane distance for "data-to-template" in ICP. More...

class	NormalErrorFunctionT
	The NormalErrorFunction computes a "point-to-plane" (signed) distance from a target point to the plane defined by a local point and a local normal vector. More...

class	OnlineBandedHouseholderQR

class	OnlineBlockHouseholderQR

class	OnlineHouseholderQR

struct	OrientationConstraintStateT

struct	OrientationConstraintT

struct	OrientationDataT
	Constraint data on 3x3 rotation represented in quaternions. More...

class	OrientationErrorFunctionT
	The OrientationErrorFunction minimizes the F-norm of the element-wise difference of a 3x3 rotation matrix to a target rotation. More...

struct	ParameterLimit

struct	ParameterTransformT
	A parameter transform is an abstraction of the joint parameters that maps a model_parameter vector to a joint_parameter vector. More...

struct	PerFrameStateT

struct	PlaneDataT
	Point-on-plane or Point-in-half-plane constraint data. More...

class	PlaneErrorFunctionT
	The PlaneErrorFunction computes the point-on-plane error or point-in-half-plane error. More...

struct	PointTriangleVertexConstraintT

class	PointTriangleVertexErrorFunctionT
	Support constraining different parts of the mesh together by specifying that a source vertex should target a location on the mesh defined by a target triangle and its normal. More...

struct	PolygonData

struct	PoseConstraint

class	PosePriorErrorFunctionT

struct	PoseShape
	Computes shape deformations based on joint rotations. More...

class	PoseTransformSolverT
	Solver which can be reused to repeatedly apply the transformPose function listed above. More...

struct	PositionConstraintStateT

struct	PositionConstraintT

struct	PositionDataT
	3D position constraint data More...

class	PositionErrorFunctionT
	The PositionErrorFunction computes the 3D positional errors from a list of Constraints. More...

class	ProgressBar

struct	ProjectionConstraintDataT

class	ProjectionErrorFunctionT

class	Random
	A consolidated random number generator to provide convenient APIs wrapping around the random library of C++ standard library <random>. More...

struct	RefineConfig
	Configuration for refining an already tracked motion, eg. More...

class	ResizeableMatrix

class	SequenceErrorFunctionT

class	SequenceSolverFunctionT

struct	SequenceSolverOptions
	Sequence solver specific options. More...

class	SequenceSolverT

class	SimdCollisionErrorFunctionT
	Represents an error function that penalizes self-intersections between collision geometries of the character. More...

class	SimdGeneralizedLossT
	SIMD version of the generalized loss function. More...

struct	SimdNormalConstraints

class	SimdNormalErrorFunction
	A highly optimized error function for "point-to-plane" (signed) distance errors. More...

struct	SimdPlaneConstraints

class	SimdPlaneErrorFunction
	A highly optimized error function for "point-on-plane" or "point-in-half-plane" errors. More...

struct	SimdPositionConstraints

class	SimdPositionErrorFunction
	A highly optimized error function for 3d position errors. More...

class	SkeletonErrorFunctionT

class	SkeletonSolverFunctionT

struct	SkeletonStateT
	Represents the complete state of a skeleton. More...

struct	SkeletonT
	The skeletal structure of a momentum Character. More...

struct	SkinnedLocator
	A skinned locator is a locator which can be attached to multiple bones. More...

struct	SkinnedLocatorConstraintT
	Constraint structure for skinned locator error function. More...

class	SkinnedLocatorErrorFunctionT
	Error function for skinned locator constraints. More...

struct	SkinnedLocatorTriangleConstraintT

class	SkinnedLocatorTriangleErrorFunctionT
	Support constraining a skinned locator to a location on the mesh defined by a target triangle and its normal. More...

class	SkinningWeightIteratorT

struct	SkinWeights
	Stores skinning weights and joint indices for character mesh deformation. More...

class	SolverFunctionT
	Abstract base class for optimization objective functions. More...

struct	SolverOptions
	Common options for numerical optimization solvers. More...

class	SolverT
	Base class for numerical optimization solvers. More...

struct	spanstreambuf
	Stream buffer based on a span. More...

class	StateErrorFunctionT

class	StateSequenceErrorFunctionT
	Error function that penalizes the difference between the current skeleton state and the next skeleton state. More...

struct	StateSimilarity
	Measures of similarity between two skeleton states. More...

struct	SubsetGaussNewtonSolverOptions
	Extended options for the Subset Gauss-Newton optimization algorithm. More...

class	SubsetGaussNewtonSolverT
	Gauss-Newton solver that optimizes only a selected subset of parameters. More...

struct	TaperedCapsuleT
	Tapered capsule collision geometry for character collision detection. More...

struct	TrackingConfig
	Configuration for pose tracking given a calibrated body and locators. More...

struct	TransformT
	Lightweight transform with separate rotation, translation, and uniform scaling. More...

struct	TrustRegionQROptions
	Trust Region with QR decomposition specific options. More...

class	TrustRegionQRT

class	UnionErrorFunctionT

struct	VertexConstraintT

class	VertexErrorFunctionT

struct	VertexProjectionConstraintT

class	VertexProjectionErrorFunctionT

class	VertexSequenceErrorFunctionT
	Error function that penalizes differences in vertex velocity between source and target motion. More...

struct	VertexVelocityConstraintT
	Constraint structure for vertex velocity. More...

struct	VertexVertexDistanceConstraintT
	Constraint for vertex-to-vertex distance errors. More...

class	VertexVertexDistanceErrorFunctionT
	Error function for vertex-to-vertex distance constraints. More...

Typedefs
using	ProgressBar_p = ::std::shared_ptr< ProgressBar >

using	ProgressBar_u = ::std::unique_ptr< ProgressBar >

using	ProgressBar_w = ::std::weak_ptr< ProgressBar >

using	ProgressBar_const_p = ::std::shared_ptr< const ProgressBar >

using	ProgressBar_const_u = ::std::unique_ptr< const ProgressBar >

using	ProgressBar_const_w = ::std::weak_ptr< const ProgressBar >

template<typename T >
using	Packet = drjit::Packet< T, kSimdPacketSize >

using	FloatP = Packet< float >

using	DoubleP = Packet< double >

using	IntP = Packet< int >

template<typename T , int Dim>
using	VectorP = drjit::Array< Packet< T >, Dim >

template<typename T >
using	Vector2P = VectorP< T, 2 >

template<typename T >
using	Vector3P = VectorP< T, 3 >

using	Vector2fP = Vector2P< float >

using	Vector3fP = Vector3P< float >

using	Vector2dP = Vector2P< double >

using	Vector3dP = Vector3P< double >

using	Mesh = MeshT< float >

using	Meshd = MeshT< double >

using	Mesh_p = ::std::shared_ptr< Mesh >

using	Mesh_u = ::std::unique_ptr< Mesh >

using	Mesh_w = ::std::weak_ptr< Mesh >

using	Mesh_const_p = ::std::shared_ptr< const Mesh >

using	Mesh_const_u = ::std::unique_ptr< const Mesh >

using	Mesh_const_w = ::std::weak_ptr< const Mesh >

using	Meshd_p = ::std::shared_ptr< Meshd >

using	Meshd_u = ::std::unique_ptr< Meshd >

using	Meshd_w = ::std::weak_ptr< Meshd >

using	Meshd_const_p = ::std::shared_ptr< const Meshd >

using	Meshd_const_u = ::std::unique_ptr< const Meshd >

using	Meshd_const_w = ::std::weak_ptr< const Meshd >

using	Mppca = MppcaT< float >

using	Mppcad = MppcaT< double >

using	Mppca_p = ::std::shared_ptr< Mppca >

using	Mppca_u = ::std::unique_ptr< Mppca >

using	Mppca_w = ::std::weak_ptr< Mppca >

using	Mppca_const_p = ::std::shared_ptr< const Mppca >

using	Mppca_const_u = ::std::unique_ptr< const Mppca >

using	Mppca_const_w = ::std::weak_ptr< const Mppca >

using	Mppcad_p = ::std::shared_ptr< Mppcad >

using	Mppcad_u = ::std::unique_ptr< Mppcad >

using	Mppcad_w = ::std::weak_ptr< Mppcad >

using	Mppcad_const_p = ::std::shared_ptr< const Mppcad >

using	Mppcad_const_u = ::std::unique_ptr< const Mppcad >

using	Mppcad_const_w = ::std::weak_ptr< const Mppcad >

using	Transform = TransformT< float >

using	Transformd = TransformT< double >

using	Transform_p = ::std::shared_ptr< Transform >

using	Transform_u = ::std::unique_ptr< Transform >

using	Transform_w = ::std::weak_ptr< Transform >

using	Transform_const_p = ::std::shared_ptr< const Transform >

using	Transform_const_u = ::std::unique_ptr< const Transform >

using	Transform_const_w = ::std::weak_ptr< const Transform >

using	Transformd_p = ::std::shared_ptr< Transformd >

using	Transformd_u = ::std::unique_ptr< Transformd >

using	Transformd_w = ::std::weak_ptr< Transformd >

using	Transformd_const_p = ::std::shared_ptr< const Transformd >

using	Transformd_const_u = ::std::unique_ptr< const Transformd >

using	Transformd_const_w = ::std::weak_ptr< const Transformd >

using	LowRankCovarianceMatrix = LowRankCovarianceMatrixT< float >

using	LowRankCovarianceMatrixd = LowRankCovarianceMatrixT< double >

using	LowRankCovarianceMatrix_p = ::std::shared_ptr< LowRankCovarianceMatrix >

using	LowRankCovarianceMatrix_u = ::std::unique_ptr< LowRankCovarianceMatrix >

using	LowRankCovarianceMatrix_w = ::std::weak_ptr< LowRankCovarianceMatrix >

using	LowRankCovarianceMatrix_const_p = ::std::shared_ptr< const LowRankCovarianceMatrix >

using	LowRankCovarianceMatrix_const_u = ::std::unique_ptr< const LowRankCovarianceMatrix >

using	LowRankCovarianceMatrix_const_w = ::std::weak_ptr< const LowRankCovarianceMatrix >

using	LowRankCovarianceMatrixd_p = ::std::shared_ptr< LowRankCovarianceMatrixd >

using	LowRankCovarianceMatrixd_u = ::std::unique_ptr< LowRankCovarianceMatrixd >

using	LowRankCovarianceMatrixd_w = ::std::weak_ptr< LowRankCovarianceMatrixd >

using	LowRankCovarianceMatrixd_const_p = ::std::shared_ptr< const LowRankCovarianceMatrixd >

using	LowRankCovarianceMatrixd_const_u = ::std::unique_ptr< const LowRankCovarianceMatrixd >

using	LowRankCovarianceMatrixd_const_w = ::std::weak_ptr< const LowRankCovarianceMatrixd >

using	GeneralizedLoss = GeneralizedLossT< float >

using	GeneralizedLossd = GeneralizedLossT< double >

using	GeneralizedLoss_p = ::std::shared_ptr< GeneralizedLoss >

using	GeneralizedLoss_u = ::std::unique_ptr< GeneralizedLoss >

using	GeneralizedLoss_w = ::std::weak_ptr< GeneralizedLoss >

using	GeneralizedLoss_const_p = ::std::shared_ptr< const GeneralizedLoss >

using	GeneralizedLoss_const_u = ::std::unique_ptr< const GeneralizedLoss >

using	GeneralizedLoss_const_w = ::std::weak_ptr< const GeneralizedLoss >

using	GeneralizedLossd_p = ::std::shared_ptr< GeneralizedLossd >

using	GeneralizedLossd_u = ::std::unique_ptr< GeneralizedLossd >

using	GeneralizedLossd_w = ::std::weak_ptr< GeneralizedLossd >

using	GeneralizedLossd_const_p = ::std::shared_ptr< const GeneralizedLossd >

using	GeneralizedLossd_const_u = ::std::unique_ptr< const GeneralizedLossd >

using	GeneralizedLossd_const_w = ::std::weak_ptr< const GeneralizedLossd >

using	SimdGeneralizedLoss = SimdGeneralizedLossT< float >

using	SimdGeneralizedLossd = SimdGeneralizedLossT< double >

using	SimdGeneralizedLoss_p = ::std::shared_ptr< SimdGeneralizedLoss >

using	SimdGeneralizedLoss_u = ::std::unique_ptr< SimdGeneralizedLoss >

using	SimdGeneralizedLoss_w = ::std::weak_ptr< SimdGeneralizedLoss >

using	SimdGeneralizedLoss_const_p = ::std::shared_ptr< const SimdGeneralizedLoss >

using	SimdGeneralizedLoss_const_u = ::std::unique_ptr< const SimdGeneralizedLoss >

using	SimdGeneralizedLoss_const_w = ::std::weak_ptr< const SimdGeneralizedLoss >

using	SimdGeneralizedLossd_p = ::std::shared_ptr< SimdGeneralizedLossd >

using	SimdGeneralizedLossd_u = ::std::unique_ptr< SimdGeneralizedLossd >

using	SimdGeneralizedLossd_w = ::std::weak_ptr< SimdGeneralizedLossd >

using	SimdGeneralizedLossd_const_p = ::std::shared_ptr< const SimdGeneralizedLossd >

using	SimdGeneralizedLossd_const_u = ::std::unique_ptr< const SimdGeneralizedLossd >

using	SimdGeneralizedLossd_const_w = ::std::weak_ptr< const SimdGeneralizedLossd >

template<typename T >
using	TransformListT = std::vector< TransformT< T > >

using	TransformList = TransformListT< float >

template<class T >
using	Map = Eigen::Map< T >

template<class T >
using	Ref = Eigen::Ref< T >

template<typename Scalar , int Dim>
using	Line = Eigen::ParametrizedLine< Scalar, Dim >

template<typename Scalar , int Dim>
using	Plane = Eigen::Hyperplane< Scalar, Dim >

template<typename Scalar , int Dim>
using	Box = Eigen::AlignedBox< Scalar, Dim >

template<int Dim>
using	Boxf = Eigen::AlignedBox< float, Dim >

template<int Dim>
using	Boxd = Eigen::AlignedBox< double, Dim >

template<int Dim>
using	Boxi = Eigen::AlignedBox< std::int32_t, Dim >

template<typename T >
using	Box2 = Eigen::AlignedBox< T, 2 >

template<typename T >
using	Box3 = Eigen::AlignedBox< T, 3 >

using	Box2f = Box2< float >

using	Box3f = Box3< float >

using	Box2d = Box2< double >

using	Box3d = Box3< double >

using	Box2i = Box2< std::int32_t >

using	Box3i = Box3< std::int32_t >

template<typename T >
using	MatrixX = Eigen::Matrix< T, Dynamic, Dynamic >

using	MatrixXf = MatrixX< float >

using	MatrixXd = MatrixX< double >

using	MatrixXb = MatrixX< std::uint8_t >

using	MatrixXs = MatrixX< std::uint16_t >

using	MatrixXu = MatrixX< std::uint32_t >

using	MatrixXi = MatrixX< std::int32_t >

template<typename T >
using	Matrix0 = Eigen::Matrix< T, 0, 0 >

template<typename T >
using	Matrix1 = Eigen::Matrix< T, 1, 1 >

template<typename T >
using	Matrix2 = Eigen::Matrix< T, 2, 2 >

template<typename T >
using	Matrix3 = Eigen::Matrix< T, 3, 3 >

template<typename T >
using	Matrix4 = Eigen::Matrix< T, 4, 4 >

template<typename T >
using	Matrix5 = Eigen::Matrix< T, 5, 5 >

template<typename T >
using	Matrix6 = Eigen::Matrix< T, 6, 6 >

using	Matrix0f = Matrix0< float >

using	Matrix1f = Matrix1< float >

using	Matrix2f = Matrix2< float >

using	Matrix3f = Matrix3< float >

using	Matrix4f = Matrix4< float >

using	Matrix5f = Matrix5< float >

using	Matrix6f = Matrix6< float >

using	Matrix0d = Matrix0< double >

using	Matrix1d = Matrix1< double >

using	Matrix2d = Matrix2< double >

using	Matrix3d = Matrix3< double >

using	Matrix4d = Matrix4< double >

using	Matrix5d = Matrix5< double >

using	Matrix6d = Matrix6< double >

using	Matrix0b = Matrix0< std::uint8_t >

using	Matrix1b = Matrix1< std::uint8_t >

using	Matrix2b = Matrix2< std::uint8_t >

using	Matrix3b = Matrix3< std::uint8_t >

using	Matrix4b = Matrix4< std::uint8_t >

using	Matrix5b = Matrix5< std::uint8_t >

using	Matrix6b = Matrix6< std::uint8_t >

using	Matrix0s = Matrix0< std::uint16_t >

using	Matrix1s = Matrix1< std::uint16_t >

using	Matrix2s = Matrix2< std::uint16_t >

using	Matrix3s = Matrix3< std::uint16_t >

using	Matrix4s = Matrix4< std::uint16_t >

using	Matrix5s = Matrix5< std::uint16_t >

using	Matrix6s = Matrix6< std::uint16_t >

using	Matrix0u = Matrix0< std::uint32_t >

using	Matrix1u = Matrix1< std::uint32_t >

using	Matrix2u = Matrix2< std::uint32_t >

using	Matrix3u = Matrix3< std::uint32_t >

using	Matrix4u = Matrix4< std::uint32_t >

using	Matrix5u = Matrix5< std::uint32_t >

using	Matrix6u = Matrix6< std::uint32_t >

using	Matrix0i = Matrix0< std::int32_t >

using	Matrix1i = Matrix1< std::int32_t >

using	Matrix2i = Matrix2< std::int32_t >

using	Matrix3i = Matrix3< std::int32_t >

using	Matrix4i = Matrix4< std::int32_t >

using	Matrix5i = Matrix5< std::int32_t >

using	Matrix6i = Matrix6< std::int32_t >

template<typename T >
using	Matrix3X = Eigen::Matrix< T, 3, Dynamic >

using	Matrix3Xf = Matrix3X< float >

using	Matrix3Xd = Matrix3X< double >

using	Matrix3Xb = Matrix3X< std::uint8_t >

using	Matrix3Xs = Matrix3X< std::uint16_t >

using	Matrix3Xu = Matrix3X< std::uint32_t >

using	Matrix3Xi = Matrix3X< std::int32_t >

template<typename T >
using	MatrixX3 = Eigen::Matrix< T, Dynamic, 3 >

using	MatrixX3f = MatrixX3< float >

using	MatrixX3d = MatrixX3< double >

using	MatrixX3b = MatrixX3< std::uint8_t >

using	MatrixX3s = MatrixX3< std::uint16_t >

using	MatrixX3u = MatrixX3< std::uint32_t >

using	MatrixX3i = MatrixX3< std::int32_t >

template<typename T , int N, int M = N>
using	RowMatrix = Eigen::Matrix< T, N, M, Eigen::RowMajor >

template<typename T >
using	RowMatrixX = RowMatrix< T, Dynamic >

template<typename T >
using	SparseMatrix = Eigen::SparseMatrix< T >

using	SparseMatrixf = SparseMatrix< float >

using	SparseMatrixd = SparseMatrix< double >

using	SparseMatrixb = SparseMatrix< std::uint8_t >

using	SparseMatrixs = SparseMatrix< std::uint16_t >

using	SparseMatrixu = SparseMatrix< std::uint32_t >

using	SparseMatrixi = SparseMatrix< std::int32_t >

template<typename T >
using	SparseRowMatrix = Eigen::SparseMatrix< T, Eigen::RowMajor >

using	SparseRowMatrixf = SparseRowMatrix< float >

using	SparseRowMatrixd = SparseRowMatrix< double >

using	SparseRowMatrixb = SparseRowMatrix< std::uint8_t >

using	SparseRowMatrixs = SparseRowMatrix< std::uint16_t >

using	SparseRowMatrixu = SparseRowMatrix< std::uint32_t >

using	SparseRowMatrixi = SparseRowMatrix< std::int32_t >

template<typename T , int Dim, int Options = 0>
using	Vector = Eigen::Matrix< T, Dim, 1, Options >

template<typename T >
using	VectorX = Vector< T, Dynamic >

using	VectorXf = VectorX< float >

using	VectorXd = VectorX< double >

using	VectorXb = VectorX< std::uint8_t >

using	VectorXs = VectorX< std::uint16_t >

using	VectorXu = VectorX< std::uint32_t >

using	VectorXi = VectorX< std::int32_t >

template<int Dim>
using	Vectorf = Vector< float, Dim >

template<int Dim>
using	Vectord = Vector< double, Dim >

template<int Dim>
using	Vectorb = Vector< std::uint8_t, Dim >

template<int Dim>
using	Vectors = Vector< std::uint16_t, Dim >

template<int Dim>
using	Vectoru = Vector< std::uint32_t, Dim >

template<int Dim>
using	Vectori = Vector< std::int32_t, Dim >

template<typename T >
using	Vector0 = Vector< T, 0 >

template<typename T >
using	Vector1 = Vector< T, 1 >

template<typename T >
using	Vector2 = Vector< T, 2 >

template<typename T >
using	Vector3 = Vector< T, 3 >

template<typename T >
using	Vector4 = Vector< T, 4 >

template<typename T >
using	Vector5 = Vector< T, 5 >

template<typename T >
using	Vector6 = Vector< T, 6 >

template<typename T >
using	Vector7 = Vector< T, 7 >

template<typename T >
using	Vector8 = Vector< T, 8 >

using	Vector0f = Vector0< float >

using	Vector1f = Vector1< float >

using	Vector2f = Vector2< float >

using	Vector3f = Vector3< float >

using	Vector4f = Vector4< float >

using	Vector5f = Vector5< float >

using	Vector6f = Vector6< float >

using	Vector7f = Vector7< float >

using	Vector8f = Vector8< float >

using	Vector0d = Vector0< double >

using	Vector1d = Vector1< double >

using	Vector2d = Vector2< double >

using	Vector3d = Vector3< double >

using	Vector4d = Vector4< double >

using	Vector5d = Vector5< double >

using	Vector6d = Vector6< double >

using	Vector0b = Vector0< std::uint8_t >

using	Vector1b = Vector1< std::uint8_t >

using	Vector2b = Vector2< std::uint8_t >

using	Vector3b = Vector3< std::uint8_t >

using	Vector4b = Vector4< std::uint8_t >

using	Vector5b = Vector5< std::uint8_t >

using	Vector6b = Vector6< std::uint8_t >

using	Vector0s = Vector0< std::uint16_t >

using	Vector1s = Vector1< std::uint16_t >

using	Vector2s = Vector2< std::uint16_t >

using	Vector3s = Vector3< std::uint16_t >

using	Vector4s = Vector4< std::uint16_t >

using	Vector5s = Vector5< std::uint16_t >

using	Vector6s = Vector6< std::uint16_t >

using	Vector0u = Vector0< std::uint32_t >

using	Vector1u = Vector1< std::uint32_t >

using	Vector2u = Vector2< std::uint32_t >

using	Vector3u = Vector3< std::uint32_t >

using	Vector4u = Vector4< std::uint32_t >

using	Vector5u = Vector5< std::uint32_t >

using	Vector6u = Vector6< std::uint32_t >

using	Vector0i = Vector0< std::int32_t >

using	Vector1i = Vector1< std::int32_t >

using	Vector2i = Vector2< std::int32_t >

using	Vector3i = Vector3< std::int32_t >

using	Vector4i = Vector4< std::int32_t >

using	Vector5i = Vector5< std::int32_t >

using	Vector6i = Vector6< std::int32_t >

template<typename T , int Dim>
using	RowVector = Eigen::Matrix< T, 1, Dim >

template<typename T >
using	RowVectorX = RowVector< T, Dynamic >

using	RowVectorXf = RowVectorX< float >

using	RowVectorXd = RowVectorX< double >

using	RowVectorXb = RowVectorX< std::uint8_t >

using	RowVectorXs = RowVectorX< std::uint16_t >

using	RowVectorXu = RowVectorX< std::uint32_t >

using	RowVectorXi = RowVectorX< std::int32_t >

template<typename T >
using	RowVector0 = RowVector< T, 0 >

template<typename T >
using	RowVector1 = RowVector< T, 1 >

template<typename T >
using	RowVector2 = RowVector< T, 2 >

template<typename T >
using	RowVector3 = RowVector< T, 3 >

template<typename T >
using	RowVector4 = RowVector< T, 4 >

template<typename T >
using	RowVector5 = RowVector< T, 5 >

template<typename T >
using	RowVector6 = RowVector< T, 6 >

using	RowVector0f = RowVector0< float >

using	RowVector1f = RowVector1< float >

using	RowVector2f = RowVector2< float >

using	RowVector3f = RowVector3< float >

using	RowVector4f = RowVector4< float >

using	RowVector5f = RowVector5< float >

using	RowVector6f = RowVector6< float >

using	RowVector0d = RowVector0< double >

using	RowVector1d = RowVector1< double >

using	RowVector2d = RowVector2< double >

using	RowVector3d = RowVector3< double >

using	RowVector4d = RowVector4< double >

using	RowVector5d = RowVector5< double >

using	RowVector6d = RowVector6< double >

using	RowVector0b = RowVector0< std::uint8_t >

using	RowVector1b = RowVector1< std::uint8_t >

using	RowVector2b = RowVector2< std::uint8_t >

using	RowVector3b = RowVector3< std::uint8_t >

using	RowVector4b = RowVector4< std::uint8_t >

using	RowVector5b = RowVector5< std::uint8_t >

using	RowVector6b = RowVector6< std::uint8_t >

using	RowVector0s = RowVector0< std::uint16_t >

using	RowVector1s = RowVector1< std::uint16_t >

using	RowVector2s = RowVector2< std::uint16_t >

using	RowVector3s = RowVector3< std::uint16_t >

using	RowVector4s = RowVector4< std::uint16_t >

using	RowVector5s = RowVector5< std::uint16_t >

using	RowVector6s = RowVector6< std::uint16_t >

using	RowVector0u = RowVector0< std::uint32_t >

using	RowVector1u = RowVector1< std::uint32_t >

using	RowVector2u = RowVector2< std::uint32_t >

using	RowVector3u = RowVector3< std::uint32_t >

using	RowVector4u = RowVector4< std::uint32_t >

using	RowVector5u = RowVector5< std::uint32_t >

using	RowVector6u = RowVector6< std::uint32_t >

using	RowVector0i = RowVector0< std::int32_t >

using	RowVector1i = RowVector1< std::int32_t >

using	RowVector2i = RowVector2< std::int32_t >

using	RowVector3i = RowVector3< std::int32_t >

using	RowVector4i = RowVector4< std::int32_t >

using	RowVector5i = RowVector5< std::int32_t >

using	RowVector6i = RowVector6< std::int32_t >

template<typename T >
using	AngleAxis = Eigen::AngleAxis< T >

using	AngleAxisf = AngleAxis< float >

using	AngleAxisd = AngleAxis< double >

template<typename T >
using	Quaternion = Eigen::Quaternion< T >

using	Quaternionf = Quaternion< float >

using	Quaterniond = Quaternion< double >

template<typename T >
using	Translation3 = Eigen::Translation< T, 3 >

using	Translation3f = Translation3< float >

using	Translation3d = Translation3< double >

template<typename T >
using	Isometry3 = Eigen::Transform< T, 3, Eigen::Isometry >

using	Isometry3f = Isometry3< float >

using	Isometry3d = Isometry3< double >

template<typename T >
using	Affine3 = Eigen::Transform< T, 3, Eigen::Affine >

using	Affine3f = Affine3< float >

using	Affine3d = Affine3< double >

using	TransformationList = std::vector< Affine3f >

template<typename T >
using	TransformationListT = std::vector< Affine3< T > >

using	VertexArray = Matrix3Xf

using	NormalArray = Matrix3Xf

using	TriangleArray = Matrix3Xi

using	ColorArray = Matrix3Xb

using	ParameterSet = std::bitset< kMaxModelParams >

using	SolverOptions_p = ::std::shared_ptr< SolverOptions >

using	SolverOptions_u = ::std::unique_ptr< SolverOptions >

using	SolverOptions_w = ::std::weak_ptr< SolverOptions >

using	SolverOptions_const_p = ::std::shared_ptr< const SolverOptions >

using	SolverOptions_const_u = ::std::unique_ptr< const SolverOptions >

using	SolverOptions_const_w = ::std::weak_ptr< const SolverOptions >

using	GaussNewtonSolverOptions_p = ::std::shared_ptr< GaussNewtonSolverOptions >

using	GaussNewtonSolverOptions_u = ::std::unique_ptr< GaussNewtonSolverOptions >

using	GaussNewtonSolverOptions_w = ::std::weak_ptr< GaussNewtonSolverOptions >

using	GaussNewtonSolverOptions_const_p = ::std::shared_ptr< const GaussNewtonSolverOptions >

using	GaussNewtonSolverOptions_const_u = ::std::unique_ptr< const GaussNewtonSolverOptions >

using	GaussNewtonSolverOptions_const_w = ::std::weak_ptr< const GaussNewtonSolverOptions >

using	Solver = SolverT< float >

using	Solverd = SolverT< double >

using	Solver_p = ::std::shared_ptr< Solver >

using	Solver_u = ::std::unique_ptr< Solver >

using	Solver_w = ::std::weak_ptr< Solver >

using	Solver_const_p = ::std::shared_ptr< const Solver >

using	Solver_const_u = ::std::unique_ptr< const Solver >

using	Solver_const_w = ::std::weak_ptr< const Solver >

using	Solverd_p = ::std::shared_ptr< Solverd >

using	Solverd_u = ::std::unique_ptr< Solverd >

using	Solverd_w = ::std::weak_ptr< Solverd >

using	Solverd_const_p = ::std::shared_ptr< const Solverd >

using	Solverd_const_u = ::std::unique_ptr< const Solverd >

using	Solverd_const_w = ::std::weak_ptr< const Solverd >

using	SolverFunction = SolverFunctionT< float >

using	SolverFunctiond = SolverFunctionT< double >

using	SolverFunction_p = ::std::shared_ptr< SolverFunction >

using	SolverFunction_u = ::std::unique_ptr< SolverFunction >

using	SolverFunction_w = ::std::weak_ptr< SolverFunction >

using	SolverFunction_const_p = ::std::shared_ptr< const SolverFunction >

using	SolverFunction_const_u = ::std::unique_ptr< const SolverFunction >

using	SolverFunction_const_w = ::std::weak_ptr< const SolverFunction >

using	SolverFunctiond_p = ::std::shared_ptr< SolverFunctiond >

using	SolverFunctiond_u = ::std::unique_ptr< SolverFunctiond >

using	SolverFunctiond_w = ::std::weak_ptr< SolverFunctiond >

using	SolverFunctiond_const_p = ::std::shared_ptr< const SolverFunctiond >

using	SolverFunctiond_const_u = ::std::unique_ptr< const SolverFunctiond >

using	SolverFunctiond_const_w = ::std::weak_ptr< const SolverFunctiond >

using	GaussNewtonSolver = GaussNewtonSolverT< float >

using	GaussNewtonSolverd = GaussNewtonSolverT< double >

using	GaussNewtonSolver_p = ::std::shared_ptr< GaussNewtonSolver >

using	GaussNewtonSolver_u = ::std::unique_ptr< GaussNewtonSolver >

using	GaussNewtonSolver_w = ::std::weak_ptr< GaussNewtonSolver >

using	GaussNewtonSolver_const_p = ::std::shared_ptr< const GaussNewtonSolver >

using	GaussNewtonSolver_const_u = ::std::unique_ptr< const GaussNewtonSolver >

using	GaussNewtonSolver_const_w = ::std::weak_ptr< const GaussNewtonSolver >

using	GaussNewtonSolverd_p = ::std::shared_ptr< GaussNewtonSolverd >

using	GaussNewtonSolverd_u = ::std::unique_ptr< GaussNewtonSolverd >

using	GaussNewtonSolverd_w = ::std::weak_ptr< GaussNewtonSolverd >

using	GaussNewtonSolverd_const_p = ::std::shared_ptr< const GaussNewtonSolverd >

using	GaussNewtonSolverd_const_u = ::std::unique_ptr< const GaussNewtonSolverd >

using	GaussNewtonSolverd_const_w = ::std::weak_ptr< const GaussNewtonSolverd >

using	GradientDescentSolver = GradientDescentSolverT< float >

using	GradientDescentSolverd = GradientDescentSolverT< double >

using	GradientDescentSolver_p = ::std::shared_ptr< GradientDescentSolver >

using	GradientDescentSolver_u = ::std::unique_ptr< GradientDescentSolver >

using	GradientDescentSolver_w = ::std::weak_ptr< GradientDescentSolver >

using	GradientDescentSolver_const_p = ::std::shared_ptr< const GradientDescentSolver >

using	GradientDescentSolver_const_u = ::std::unique_ptr< const GradientDescentSolver >

using	GradientDescentSolver_const_w = ::std::weak_ptr< const GradientDescentSolver >

using	GradientDescentSolverd_p = ::std::shared_ptr< GradientDescentSolverd >

using	GradientDescentSolverd_u = ::std::unique_ptr< GradientDescentSolverd >

using	GradientDescentSolverd_w = ::std::weak_ptr< GradientDescentSolverd >

using	GradientDescentSolverd_const_p = ::std::shared_ptr< const GradientDescentSolverd >

using	GradientDescentSolverd_const_u = ::std::unique_ptr< const GradientDescentSolverd >

using	GradientDescentSolverd_const_w = ::std::weak_ptr< const GradientDescentSolverd >

using	SubsetGaussNewtonSolver = SubsetGaussNewtonSolverT< float >

using	SubsetGaussNewtonSolverd = SubsetGaussNewtonSolverT< double >

using	SubsetGaussNewtonSolver_p = ::std::shared_ptr< SubsetGaussNewtonSolver >

using	SubsetGaussNewtonSolver_u = ::std::unique_ptr< SubsetGaussNewtonSolver >

using	SubsetGaussNewtonSolver_w = ::std::weak_ptr< SubsetGaussNewtonSolver >

using	SubsetGaussNewtonSolver_const_p = ::std::shared_ptr< const SubsetGaussNewtonSolver >

using	SubsetGaussNewtonSolver_const_u = ::std::unique_ptr< const SubsetGaussNewtonSolver >

using	SubsetGaussNewtonSolver_const_w = ::std::weak_ptr< const SubsetGaussNewtonSolver >

using	SubsetGaussNewtonSolverd_p = ::std::shared_ptr< SubsetGaussNewtonSolverd >

using	SubsetGaussNewtonSolverd_u = ::std::unique_ptr< SubsetGaussNewtonSolverd >

using	SubsetGaussNewtonSolverd_w = ::std::weak_ptr< SubsetGaussNewtonSolverd >

using	SubsetGaussNewtonSolverd_const_p = ::std::shared_ptr< const SubsetGaussNewtonSolverd >

using	SubsetGaussNewtonSolverd_const_u = ::std::unique_ptr< const SubsetGaussNewtonSolverd >

using	SubsetGaussNewtonSolverd_const_w = ::std::weak_ptr< const SubsetGaussNewtonSolverd >

template<typename S >
using	CollisionGeometryT = std::vector< TaperedCapsuleT< S > >
	Collection of tapered capsules representing a character's collision geometry.

using	CollisionGeometry = CollisionGeometryT< float >

using	CollisionGeometryd = CollisionGeometryT< double >

using	BlendShape_p = ::std::shared_ptr< BlendShape >

using	BlendShape_u = ::std::unique_ptr< BlendShape >

using	BlendShape_w = ::std::weak_ptr< BlendShape >

using	BlendShape_const_p = ::std::shared_ptr< const BlendShape >

using	BlendShape_const_u = ::std::unique_ptr< const BlendShape >

using	BlendShape_const_w = ::std::weak_ptr< const BlendShape >

using	BlendShapeBase_p = ::std::shared_ptr< BlendShapeBase >

using	BlendShapeBase_u = ::std::unique_ptr< BlendShapeBase >

using	BlendShapeBase_w = ::std::weak_ptr< BlendShapeBase >

using	BlendShapeBase_const_p = ::std::shared_ptr< const BlendShapeBase >

using	BlendShapeBase_const_u = ::std::unique_ptr< const BlendShapeBase >

using	BlendShapeBase_const_w = ::std::weak_ptr< const BlendShapeBase >

using	Locator_p = ::std::shared_ptr< Locator >

using	Locator_u = ::std::unique_ptr< Locator >

using	Locator_w = ::std::weak_ptr< Locator >

using	Locator_const_p = ::std::shared_ptr< const Locator >

using	Locator_const_u = ::std::unique_ptr< const Locator >

using	Locator_const_w = ::std::weak_ptr< const Locator >

using	PoseShape_p = ::std::shared_ptr< PoseShape >

using	PoseShape_u = ::std::unique_ptr< PoseShape >

using	PoseShape_w = ::std::weak_ptr< PoseShape >

using	PoseShape_const_p = ::std::shared_ptr< const PoseShape >

using	PoseShape_const_u = ::std::unique_ptr< const PoseShape >

using	PoseShape_const_w = ::std::weak_ptr< const PoseShape >

using	SkinWeights_p = ::std::shared_ptr< SkinWeights >

using	SkinWeights_u = ::std::unique_ptr< SkinWeights >

using	SkinWeights_w = ::std::weak_ptr< SkinWeights >

using	SkinWeights_const_p = ::std::shared_ptr< const SkinWeights >

using	SkinWeights_const_u = ::std::unique_ptr< const SkinWeights >

using	SkinWeights_const_w = ::std::weak_ptr< const SkinWeights >

using	SkinnedLocator_p = ::std::shared_ptr< SkinnedLocator >

using	SkinnedLocator_u = ::std::unique_ptr< SkinnedLocator >

using	SkinnedLocator_w = ::std::weak_ptr< SkinnedLocator >

using	SkinnedLocator_const_p = ::std::shared_ptr< const SkinnedLocator >

using	SkinnedLocator_const_u = ::std::unique_ptr< const SkinnedLocator >

using	SkinnedLocator_const_w = ::std::weak_ptr< const SkinnedLocator >

using	Character = CharacterT< float >

using	Characterd = CharacterT< double >

using	Character_p = ::std::shared_ptr< Character >

using	Character_u = ::std::unique_ptr< Character >

using	Character_w = ::std::weak_ptr< Character >

using	Character_const_p = ::std::shared_ptr< const Character >

using	Character_const_u = ::std::unique_ptr< const Character >

using	Character_const_w = ::std::weak_ptr< const Character >

using	Characterd_p = ::std::shared_ptr< Characterd >

using	Characterd_u = ::std::unique_ptr< Characterd >

using	Characterd_w = ::std::weak_ptr< Characterd >

using	Characterd_const_p = ::std::shared_ptr< const Characterd >

using	Characterd_const_u = ::std::unique_ptr< const Characterd >

using	Characterd_const_w = ::std::weak_ptr< const Characterd >

using	CharacterState = CharacterStateT< float >

using	CharacterStated = CharacterStateT< double >

using	CharacterState_p = ::std::shared_ptr< CharacterState >

using	CharacterState_u = ::std::unique_ptr< CharacterState >

using	CharacterState_w = ::std::weak_ptr< CharacterState >

using	CharacterState_const_p = ::std::shared_ptr< const CharacterState >

using	CharacterState_const_u = ::std::unique_ptr< const CharacterState >

using	CharacterState_const_w = ::std::weak_ptr< const CharacterState >

using	CharacterStated_p = ::std::shared_ptr< CharacterStated >

using	CharacterStated_u = ::std::unique_ptr< CharacterStated >

using	CharacterStated_w = ::std::weak_ptr< CharacterStated >

using	CharacterStated_const_p = ::std::shared_ptr< const CharacterStated >

using	CharacterStated_const_u = ::std::unique_ptr< const CharacterStated >

using	CharacterStated_const_w = ::std::weak_ptr< const CharacterStated >

using	CollisionGeometryState = CollisionGeometryStateT< float >

using	CollisionGeometryStated = CollisionGeometryStateT< double >

using	CollisionGeometryState_p = ::std::shared_ptr< CollisionGeometryState >

using	CollisionGeometryState_u = ::std::unique_ptr< CollisionGeometryState >

using	CollisionGeometryState_w = ::std::weak_ptr< CollisionGeometryState >

using	CollisionGeometryState_const_p = ::std::shared_ptr< const CollisionGeometryState >

using	CollisionGeometryState_const_u = ::std::unique_ptr< const CollisionGeometryState >

using	CollisionGeometryState_const_w = ::std::weak_ptr< const CollisionGeometryState >

using	CollisionGeometryStated_p = ::std::shared_ptr< CollisionGeometryStated >

using	CollisionGeometryStated_u = ::std::unique_ptr< CollisionGeometryStated >

using	CollisionGeometryStated_w = ::std::weak_ptr< CollisionGeometryStated >

using	CollisionGeometryStated_const_p = ::std::shared_ptr< const CollisionGeometryStated >

using	CollisionGeometryStated_const_u = ::std::unique_ptr< const CollisionGeometryStated >

using	CollisionGeometryStated_const_w = ::std::weak_ptr< const CollisionGeometryStated >

using	Joint = JointT< float >

using	Jointd = JointT< double >

using	Joint_p = ::std::shared_ptr< Joint >

using	Joint_u = ::std::unique_ptr< Joint >

using	Joint_w = ::std::weak_ptr< Joint >

using	Joint_const_p = ::std::shared_ptr< const Joint >

using	Joint_const_u = ::std::unique_ptr< const Joint >

using	Joint_const_w = ::std::weak_ptr< const Joint >

using	Jointd_p = ::std::shared_ptr< Jointd >

using	Jointd_u = ::std::unique_ptr< Jointd >

using	Jointd_w = ::std::weak_ptr< Jointd >

using	Jointd_const_p = ::std::shared_ptr< const Jointd >

using	Jointd_const_u = ::std::unique_ptr< const Jointd >

using	Jointd_const_w = ::std::weak_ptr< const Jointd >

using	JointState = JointStateT< float >

using	JointStated = JointStateT< double >

using	JointState_p = ::std::shared_ptr< JointState >

using	JointState_u = ::std::unique_ptr< JointState >

using	JointState_w = ::std::weak_ptr< JointState >

using	JointState_const_p = ::std::shared_ptr< const JointState >

using	JointState_const_u = ::std::unique_ptr< const JointState >

using	JointState_const_w = ::std::weak_ptr< const JointState >

using	JointStated_p = ::std::shared_ptr< JointStated >

using	JointStated_u = ::std::unique_ptr< JointStated >

using	JointStated_w = ::std::weak_ptr< JointStated >

using	JointStated_const_p = ::std::shared_ptr< const JointStated >

using	JointStated_const_u = ::std::unique_ptr< const JointStated >

using	JointStated_const_w = ::std::weak_ptr< const JointStated >

using	ParameterTransform = ParameterTransformT< float >

using	ParameterTransformd = ParameterTransformT< double >

using	ParameterTransform_p = ::std::shared_ptr< ParameterTransform >

using	ParameterTransform_u = ::std::unique_ptr< ParameterTransform >

using	ParameterTransform_w = ::std::weak_ptr< ParameterTransform >

using	ParameterTransform_const_p = ::std::shared_ptr< const ParameterTransform >

using	ParameterTransform_const_u = ::std::unique_ptr< const ParameterTransform >

using	ParameterTransform_const_w = ::std::weak_ptr< const ParameterTransform >

using	ParameterTransformd_p = ::std::shared_ptr< ParameterTransformd >

using	ParameterTransformd_u = ::std::unique_ptr< ParameterTransformd >

using	ParameterTransformd_w = ::std::weak_ptr< ParameterTransformd >

using	ParameterTransformd_const_p = ::std::shared_ptr< const ParameterTransformd >

using	ParameterTransformd_const_u = ::std::unique_ptr< const ParameterTransformd >

using	ParameterTransformd_const_w = ::std::weak_ptr< const ParameterTransformd >

using	Skeleton = SkeletonT< float >

using	Skeletond = SkeletonT< double >

using	Skeleton_p = ::std::shared_ptr< Skeleton >

using	Skeleton_u = ::std::unique_ptr< Skeleton >

using	Skeleton_w = ::std::weak_ptr< Skeleton >

using	Skeleton_const_p = ::std::shared_ptr< const Skeleton >

using	Skeleton_const_u = ::std::unique_ptr< const Skeleton >

using	Skeleton_const_w = ::std::weak_ptr< const Skeleton >

using	Skeletond_p = ::std::shared_ptr< Skeletond >

using	Skeletond_u = ::std::unique_ptr< Skeletond >

using	Skeletond_w = ::std::weak_ptr< Skeletond >

using	Skeletond_const_p = ::std::shared_ptr< const Skeletond >

using	Skeletond_const_u = ::std::unique_ptr< const Skeletond >

using	Skeletond_const_w = ::std::weak_ptr< const Skeletond >

using	SkeletonState = SkeletonStateT< float >

using	SkeletonStated = SkeletonStateT< double >

using	SkeletonState_p = ::std::shared_ptr< SkeletonState >

using	SkeletonState_u = ::std::unique_ptr< SkeletonState >

using	SkeletonState_w = ::std::weak_ptr< SkeletonState >

using	SkeletonState_const_p = ::std::shared_ptr< const SkeletonState >

using	SkeletonState_const_u = ::std::unique_ptr< const SkeletonState >

using	SkeletonState_const_w = ::std::weak_ptr< const SkeletonState >

using	SkeletonStated_p = ::std::shared_ptr< SkeletonStated >

using	SkeletonStated_u = ::std::unique_ptr< SkeletonStated >

using	SkeletonStated_w = ::std::weak_ptr< SkeletonStated >

using	SkeletonStated_const_p = ::std::shared_ptr< const SkeletonStated >

using	SkeletonStated_const_u = ::std::unique_ptr< const SkeletonStated >

using	SkeletonStated_const_w = ::std::weak_ptr< const SkeletonStated >

using	MeshState = MeshStateT< float >

using	MeshStated = MeshStateT< double >

using	MeshState_p = ::std::shared_ptr< MeshState >

using	MeshState_u = ::std::unique_ptr< MeshState >

using	MeshState_w = ::std::weak_ptr< MeshState >

using	MeshState_const_p = ::std::shared_ptr< const MeshState >

using	MeshState_const_u = ::std::unique_ptr< const MeshState >

using	MeshState_const_w = ::std::weak_ptr< const MeshState >

using	MeshStated_p = ::std::shared_ptr< MeshStated >

using	MeshStated_u = ::std::unique_ptr< MeshStated >

using	MeshStated_w = ::std::weak_ptr< MeshStated >

using	MeshStated_const_p = ::std::shared_ptr< const MeshStated >

using	MeshStated_const_u = ::std::unique_ptr< const MeshStated >

using	MeshStated_const_w = ::std::weak_ptr< const MeshStated >

using	TaperedCapsule = TaperedCapsuleT< float >

using	TaperedCapsuled = TaperedCapsuleT< double >

using	TaperedCapsule_p = ::std::shared_ptr< TaperedCapsule >

using	TaperedCapsule_u = ::std::unique_ptr< TaperedCapsule >

using	TaperedCapsule_w = ::std::weak_ptr< TaperedCapsule >

using	TaperedCapsule_const_p = ::std::shared_ptr< const TaperedCapsule >

using	TaperedCapsule_const_u = ::std::unique_ptr< const TaperedCapsule >

using	TaperedCapsule_const_w = ::std::weak_ptr< const TaperedCapsule >

using	TaperedCapsuled_p = ::std::shared_ptr< TaperedCapsuled >

using	TaperedCapsuled_u = ::std::unique_ptr< TaperedCapsuled >

using	TaperedCapsuled_w = ::std::weak_ptr< TaperedCapsuled >

using	TaperedCapsuled_const_p = ::std::shared_ptr< const TaperedCapsuled >

using	TaperedCapsuled_const_u = ::std::unique_ptr< const TaperedCapsuled >

using	TaperedCapsuled_const_w = ::std::weak_ptr< const TaperedCapsuled >

using	InverseParameterTransform = InverseParameterTransformT< float >

using	InverseParameterTransformd = InverseParameterTransformT< double >

template<typename T >
using	JointListT = std::vector< JointT< T > >
	A list of joints (e.g., of a skeleton).

using	JointList = JointListT< float >

using	JointListd = JointListT< double >

template<typename T >
using	JointStateListT = std::vector< JointStateT< T > >
	Structure describing the state of all joints in a skeleton.

using	JointStateList = JointStateListT< float >

using	LocatorList = std::vector< Locator >
	A collection of locators attached to a skeleton.

using	ParameterLimits = std::vector< ParameterLimit >

using	ParameterSets = std::unordered_map< std::string, ParameterSet >

using	PoseConstraints = std::unordered_map< std::string, PoseConstraint >

using	IndexMatrix = Eigen::Matrix< uint32_t, Eigen::Dynamic, kMaxSkinJoints, Eigen::AutoAlign\|Eigen::RowMajor >
	Matrix type for storing joint indices that influence each vertex.

using	WeightMatrix = Eigen::Matrix< float, Eigen::Dynamic, kMaxSkinJoints, Eigen::AutoAlign\|Eigen::RowMajor >
	Matrix type for storing weights of joint influences on each vertex.

using	SkinnedLocatorList = std::vector< SkinnedLocator >
	A collection of locators attached to a skeleton.

template<typename T >
using	JointVectorT = Eigen::Matrix< T, kParametersPerJoint, 1 >

using	JointVector = JointVectorT< float >

using	ModelParameters = ModelParametersT< float >

using	ModelParametersd = ModelParametersT< double >

using	BlendWeights = BlendWeightsT< float >

using	BlendWeightsd = BlendWeightsT< double >

using	JointParameters = JointParametersT< float >

using	JointParametersd = JointParametersT< double >

using	JointStateListd = JointStateListT< double >

using	CharacterParameters = CharacterParametersT< float >

using	CharacterParametersd = CharacterParametersT< double >

using	MotionParameters = std::tuple< std::vector< std::string >, Eigen::MatrixXf >

using	IdentityParameters = std::tuple< std::vector< std::string >, Eigen::VectorXf >

using	ConstraintDataList = std::vector< ConstraintData >
	A list of ConstraintData.

template<typename T >
using	optional_ref = std::optional< std::reference_wrapper< T > >
	An optional of a reference.

using	ConstraintData_p = ::std::shared_ptr< ConstraintData >

using	ConstraintData_u = ::std::unique_ptr< ConstraintData >

using	ConstraintData_w = ::std::weak_ptr< ConstraintData >

using	ConstraintData_const_p = ::std::shared_ptr< const ConstraintData >

using	ConstraintData_const_u = ::std::unique_ptr< const ConstraintData >

using	ConstraintData_const_w = ::std::weak_ptr< const ConstraintData >

using	GaussNewtonSolverQROptions_p = ::std::shared_ptr< GaussNewtonSolverQROptions >

using	GaussNewtonSolverQROptions_u = ::std::unique_ptr< GaussNewtonSolverQROptions >

using	GaussNewtonSolverQROptions_w = ::std::weak_ptr< GaussNewtonSolverQROptions >

using	GaussNewtonSolverQROptions_const_p = ::std::shared_ptr< const GaussNewtonSolverQROptions >

using	GaussNewtonSolverQROptions_const_u = ::std::unique_ptr< const GaussNewtonSolverQROptions >

using	GaussNewtonSolverQROptions_const_w = ::std::weak_ptr< const GaussNewtonSolverQROptions >

using	SimdNormalConstraints_p = ::std::shared_ptr< SimdNormalConstraints >

using	SimdNormalConstraints_u = ::std::unique_ptr< SimdNormalConstraints >

using	SimdNormalConstraints_w = ::std::weak_ptr< SimdNormalConstraints >

using	SimdNormalConstraints_const_p = ::std::shared_ptr< const SimdNormalConstraints >

using	SimdNormalConstraints_const_u = ::std::unique_ptr< const SimdNormalConstraints >

using	SimdNormalConstraints_const_w = ::std::weak_ptr< const SimdNormalConstraints >

using	SimdPlaneConstraints_p = ::std::shared_ptr< SimdPlaneConstraints >

using	SimdPlaneConstraints_u = ::std::unique_ptr< SimdPlaneConstraints >

using	SimdPlaneConstraints_w = ::std::weak_ptr< SimdPlaneConstraints >

using	SimdPlaneConstraints_const_p = ::std::shared_ptr< const SimdPlaneConstraints >

using	SimdPlaneConstraints_const_u = ::std::unique_ptr< const SimdPlaneConstraints >

using	SimdPlaneConstraints_const_w = ::std::weak_ptr< const SimdPlaneConstraints >

using	SimdPositionConstraints_p = ::std::shared_ptr< SimdPositionConstraints >

using	SimdPositionConstraints_u = ::std::unique_ptr< SimdPositionConstraints >

using	SimdPositionConstraints_w = ::std::weak_ptr< SimdPositionConstraints >

using	SimdPositionConstraints_const_p = ::std::shared_ptr< const SimdPositionConstraints >

using	SimdPositionConstraints_const_u = ::std::unique_ptr< const SimdPositionConstraints >

using	SimdPositionConstraints_const_w = ::std::weak_ptr< const SimdPositionConstraints >

using	AimData = AimDataT< float >

using	AimDatad = AimDataT< double >

using	AimData_p = ::std::shared_ptr< AimData >

using	AimData_u = ::std::unique_ptr< AimData >

using	AimData_w = ::std::weak_ptr< AimData >

using	AimData_const_p = ::std::shared_ptr< const AimData >

using	AimData_const_u = ::std::unique_ptr< const AimData >

using	AimData_const_w = ::std::weak_ptr< const AimData >

using	AimDatad_p = ::std::shared_ptr< AimDatad >

using	AimDatad_u = ::std::unique_ptr< AimDatad >

using	AimDatad_w = ::std::weak_ptr< AimDatad >

using	AimDatad_const_p = ::std::shared_ptr< const AimDatad >

using	AimDatad_const_u = ::std::unique_ptr< const AimDatad >

using	AimDatad_const_w = ::std::weak_ptr< const AimDatad >

using	FixedAxisData = FixedAxisDataT< float >

using	FixedAxisDatad = FixedAxisDataT< double >

using	FixedAxisData_p = ::std::shared_ptr< FixedAxisData >

using	FixedAxisData_u = ::std::unique_ptr< FixedAxisData >

using	FixedAxisData_w = ::std::weak_ptr< FixedAxisData >

using	FixedAxisData_const_p = ::std::shared_ptr< const FixedAxisData >

using	FixedAxisData_const_u = ::std::unique_ptr< const FixedAxisData >

using	FixedAxisData_const_w = ::std::weak_ptr< const FixedAxisData >

using	FixedAxisDatad_p = ::std::shared_ptr< FixedAxisDatad >

using	FixedAxisDatad_u = ::std::unique_ptr< FixedAxisDatad >

using	FixedAxisDatad_w = ::std::weak_ptr< FixedAxisDatad >

using	FixedAxisDatad_const_p = ::std::shared_ptr< const FixedAxisDatad >

using	FixedAxisDatad_const_u = ::std::unique_ptr< const FixedAxisDatad >

using	FixedAxisDatad_const_w = ::std::weak_ptr< const FixedAxisDatad >

using	NormalData = NormalDataT< float >

using	NormalDatad = NormalDataT< double >

using	NormalData_p = ::std::shared_ptr< NormalData >

using	NormalData_u = ::std::unique_ptr< NormalData >

using	NormalData_w = ::std::weak_ptr< NormalData >

using	NormalData_const_p = ::std::shared_ptr< const NormalData >

using	NormalData_const_u = ::std::unique_ptr< const NormalData >

using	NormalData_const_w = ::std::weak_ptr< const NormalData >

using	NormalDatad_p = ::std::shared_ptr< NormalDatad >

using	NormalDatad_u = ::std::unique_ptr< NormalDatad >

using	NormalDatad_w = ::std::weak_ptr< NormalDatad >

using	NormalDatad_const_p = ::std::shared_ptr< const NormalDatad >

using	NormalDatad_const_u = ::std::unique_ptr< const NormalDatad >

using	NormalDatad_const_w = ::std::weak_ptr< const NormalDatad >

using	OrientationData = OrientationDataT< float >

using	OrientationDatad = OrientationDataT< double >

using	OrientationData_p = ::std::shared_ptr< OrientationData >

using	OrientationData_u = ::std::unique_ptr< OrientationData >

using	OrientationData_w = ::std::weak_ptr< OrientationData >

using	OrientationData_const_p = ::std::shared_ptr< const OrientationData >

using	OrientationData_const_u = ::std::unique_ptr< const OrientationData >

using	OrientationData_const_w = ::std::weak_ptr< const OrientationData >

using	OrientationDatad_p = ::std::shared_ptr< OrientationDatad >

using	OrientationDatad_u = ::std::unique_ptr< OrientationDatad >

using	OrientationDatad_w = ::std::weak_ptr< OrientationDatad >

using	OrientationDatad_const_p = ::std::shared_ptr< const OrientationDatad >

using	OrientationDatad_const_u = ::std::unique_ptr< const OrientationDatad >

using	OrientationDatad_const_w = ::std::weak_ptr< const OrientationDatad >

using	PointTriangleVertexConstraint = PointTriangleVertexConstraintT< float >

using	PointTriangleVertexConstraintd = PointTriangleVertexConstraintT< double >

using	PointTriangleVertexConstraint_p = ::std::shared_ptr< PointTriangleVertexConstraint >

using	PointTriangleVertexConstraint_u = ::std::unique_ptr< PointTriangleVertexConstraint >

using	PointTriangleVertexConstraint_w = ::std::weak_ptr< PointTriangleVertexConstraint >

using	PointTriangleVertexConstraint_const_p = ::std::shared_ptr< const PointTriangleVertexConstraint >

using	PointTriangleVertexConstraint_const_u = ::std::unique_ptr< const PointTriangleVertexConstraint >

using	PointTriangleVertexConstraint_const_w = ::std::weak_ptr< const PointTriangleVertexConstraint >

using	PointTriangleVertexConstraintd_p = ::std::shared_ptr< PointTriangleVertexConstraintd >

using	PointTriangleVertexConstraintd_u = ::std::unique_ptr< PointTriangleVertexConstraintd >

using	PointTriangleVertexConstraintd_w = ::std::weak_ptr< PointTriangleVertexConstraintd >

using	PointTriangleVertexConstraintd_const_p = ::std::shared_ptr< const PointTriangleVertexConstraintd >

using	PointTriangleVertexConstraintd_const_u = ::std::unique_ptr< const PointTriangleVertexConstraintd >

using	PointTriangleVertexConstraintd_const_w = ::std::weak_ptr< const PointTriangleVertexConstraintd >

using	PlaneData = PlaneDataT< float >

using	PlaneDatad = PlaneDataT< double >

using	PlaneData_p = ::std::shared_ptr< PlaneData >

using	PlaneData_u = ::std::unique_ptr< PlaneData >

using	PlaneData_w = ::std::weak_ptr< PlaneData >

using	PlaneData_const_p = ::std::shared_ptr< const PlaneData >

using	PlaneData_const_u = ::std::unique_ptr< const PlaneData >

using	PlaneData_const_w = ::std::weak_ptr< const PlaneData >

using	PlaneDatad_p = ::std::shared_ptr< PlaneDatad >

using	PlaneDatad_u = ::std::unique_ptr< PlaneDatad >

using	PlaneDatad_w = ::std::weak_ptr< PlaneDatad >

using	PlaneDatad_const_p = ::std::shared_ptr< const PlaneDatad >

using	PlaneDatad_const_u = ::std::unique_ptr< const PlaneDatad >

using	PlaneDatad_const_w = ::std::weak_ptr< const PlaneDatad >

using	PositionData = PositionDataT< float >

using	PositionDatad = PositionDataT< double >

using	PositionData_p = ::std::shared_ptr< PositionData >

using	PositionData_u = ::std::unique_ptr< PositionData >

using	PositionData_w = ::std::weak_ptr< PositionData >

using	PositionData_const_p = ::std::shared_ptr< const PositionData >

using	PositionData_const_u = ::std::unique_ptr< const PositionData >

using	PositionData_const_w = ::std::weak_ptr< const PositionData >

using	PositionDatad_p = ::std::shared_ptr< PositionDatad >

using	PositionDatad_u = ::std::unique_ptr< PositionDatad >

using	PositionDatad_w = ::std::weak_ptr< PositionDatad >

using	PositionDatad_const_p = ::std::shared_ptr< const PositionDatad >

using	PositionDatad_const_u = ::std::unique_ptr< const PositionDatad >

using	PositionDatad_const_w = ::std::weak_ptr< const PositionDatad >

using	SkinnedLocatorConstraint = SkinnedLocatorConstraintT< float >

using	SkinnedLocatorConstraintd = SkinnedLocatorConstraintT< double >

using	SkinnedLocatorConstraint_p = ::std::shared_ptr< SkinnedLocatorConstraint >

using	SkinnedLocatorConstraint_u = ::std::unique_ptr< SkinnedLocatorConstraint >

using	SkinnedLocatorConstraint_w = ::std::weak_ptr< SkinnedLocatorConstraint >

using	SkinnedLocatorConstraint_const_p = ::std::shared_ptr< const SkinnedLocatorConstraint >

using	SkinnedLocatorConstraint_const_u = ::std::unique_ptr< const SkinnedLocatorConstraint >

using	SkinnedLocatorConstraint_const_w = ::std::weak_ptr< const SkinnedLocatorConstraint >

using	SkinnedLocatorConstraintd_p = ::std::shared_ptr< SkinnedLocatorConstraintd >

using	SkinnedLocatorConstraintd_u = ::std::unique_ptr< SkinnedLocatorConstraintd >

using	SkinnedLocatorConstraintd_w = ::std::weak_ptr< SkinnedLocatorConstraintd >

using	SkinnedLocatorConstraintd_const_p = ::std::shared_ptr< const SkinnedLocatorConstraintd >

using	SkinnedLocatorConstraintd_const_u = ::std::unique_ptr< const SkinnedLocatorConstraintd >

using	SkinnedLocatorConstraintd_const_w = ::std::weak_ptr< const SkinnedLocatorConstraintd >

using	SkinnedLocatorTriangleConstraint = SkinnedLocatorTriangleConstraintT< float >

using	SkinnedLocatorTriangleConstraintd = SkinnedLocatorTriangleConstraintT< double >

using	SkinnedLocatorTriangleConstraint_p = ::std::shared_ptr< SkinnedLocatorTriangleConstraint >

using	SkinnedLocatorTriangleConstraint_u = ::std::unique_ptr< SkinnedLocatorTriangleConstraint >

using	SkinnedLocatorTriangleConstraint_w = ::std::weak_ptr< SkinnedLocatorTriangleConstraint >

using	SkinnedLocatorTriangleConstraint_const_p = ::std::shared_ptr< const SkinnedLocatorTriangleConstraint >

using	SkinnedLocatorTriangleConstraint_const_u = ::std::unique_ptr< const SkinnedLocatorTriangleConstraint >

using	SkinnedLocatorTriangleConstraint_const_w = ::std::weak_ptr< const SkinnedLocatorTriangleConstraint >

using	SkinnedLocatorTriangleConstraintd_p = ::std::shared_ptr< SkinnedLocatorTriangleConstraintd >

using	SkinnedLocatorTriangleConstraintd_u = ::std::unique_ptr< SkinnedLocatorTriangleConstraintd >

using	SkinnedLocatorTriangleConstraintd_w = ::std::weak_ptr< SkinnedLocatorTriangleConstraintd >

using	SkinnedLocatorTriangleConstraintd_const_p = ::std::shared_ptr< const SkinnedLocatorTriangleConstraintd >

using	SkinnedLocatorTriangleConstraintd_const_u = ::std::unique_ptr< const SkinnedLocatorTriangleConstraintd >

using	SkinnedLocatorTriangleConstraintd_const_w = ::std::weak_ptr< const SkinnedLocatorTriangleConstraintd >

using	VertexConstraint = VertexConstraintT< float >

using	VertexConstraintd = VertexConstraintT< double >

using	VertexConstraint_p = ::std::shared_ptr< VertexConstraint >

using	VertexConstraint_u = ::std::unique_ptr< VertexConstraint >

using	VertexConstraint_w = ::std::weak_ptr< VertexConstraint >

using	VertexConstraint_const_p = ::std::shared_ptr< const VertexConstraint >

using	VertexConstraint_const_u = ::std::unique_ptr< const VertexConstraint >

using	VertexConstraint_const_w = ::std::weak_ptr< const VertexConstraint >

using	VertexConstraintd_p = ::std::shared_ptr< VertexConstraintd >

using	VertexConstraintd_u = ::std::unique_ptr< VertexConstraintd >

using	VertexConstraintd_w = ::std::weak_ptr< VertexConstraintd >

using	VertexConstraintd_const_p = ::std::shared_ptr< const VertexConstraintd >

using	VertexConstraintd_const_u = ::std::unique_ptr< const VertexConstraintd >

using	VertexConstraintd_const_w = ::std::weak_ptr< const VertexConstraintd >

using	VertexProjectionConstraint = VertexProjectionConstraintT< float >

using	VertexProjectionConstraintd = VertexProjectionConstraintT< double >

using	VertexProjectionConstraint_p = ::std::shared_ptr< VertexProjectionConstraint >

using	VertexProjectionConstraint_u = ::std::unique_ptr< VertexProjectionConstraint >

using	VertexProjectionConstraint_w = ::std::weak_ptr< VertexProjectionConstraint >

using	VertexProjectionConstraint_const_p = ::std::shared_ptr< const VertexProjectionConstraint >

using	VertexProjectionConstraint_const_u = ::std::unique_ptr< const VertexProjectionConstraint >

using	VertexProjectionConstraint_const_w = ::std::weak_ptr< const VertexProjectionConstraint >

using	VertexProjectionConstraintd_p = ::std::shared_ptr< VertexProjectionConstraintd >

using	VertexProjectionConstraintd_u = ::std::unique_ptr< VertexProjectionConstraintd >

using	VertexProjectionConstraintd_w = ::std::weak_ptr< VertexProjectionConstraintd >

using	VertexProjectionConstraintd_const_p = ::std::shared_ptr< const VertexProjectionConstraintd >

using	VertexProjectionConstraintd_const_u = ::std::unique_ptr< const VertexProjectionConstraintd >

using	VertexProjectionConstraintd_const_w = ::std::weak_ptr< const VertexProjectionConstraintd >

using	SimdNormalErrorFunction_p = ::std::shared_ptr< SimdNormalErrorFunction >

using	SimdNormalErrorFunction_u = ::std::unique_ptr< SimdNormalErrorFunction >

using	SimdNormalErrorFunction_w = ::std::weak_ptr< SimdNormalErrorFunction >

using	SimdNormalErrorFunction_const_p = ::std::shared_ptr< const SimdNormalErrorFunction >

using	SimdNormalErrorFunction_const_u = ::std::unique_ptr< const SimdNormalErrorFunction >

using	SimdNormalErrorFunction_const_w = ::std::weak_ptr< const SimdNormalErrorFunction >

using	SimdPlaneErrorFunction_p = ::std::shared_ptr< SimdPlaneErrorFunction >

using	SimdPlaneErrorFunction_u = ::std::unique_ptr< SimdPlaneErrorFunction >

using	SimdPlaneErrorFunction_w = ::std::weak_ptr< SimdPlaneErrorFunction >

using	SimdPlaneErrorFunction_const_p = ::std::shared_ptr< const SimdPlaneErrorFunction >

using	SimdPlaneErrorFunction_const_u = ::std::unique_ptr< const SimdPlaneErrorFunction >

using	SimdPlaneErrorFunction_const_w = ::std::weak_ptr< const SimdPlaneErrorFunction >

using	SimdPositionErrorFunction_p = ::std::shared_ptr< SimdPositionErrorFunction >

using	SimdPositionErrorFunction_u = ::std::unique_ptr< SimdPositionErrorFunction >

using	SimdPositionErrorFunction_w = ::std::weak_ptr< SimdPositionErrorFunction >

using	SimdPositionErrorFunction_const_p = ::std::shared_ptr< const SimdPositionErrorFunction >

using	SimdPositionErrorFunction_const_u = ::std::unique_ptr< const SimdPositionErrorFunction >

using	SimdPositionErrorFunction_const_w = ::std::weak_ptr< const SimdPositionErrorFunction >

using	SimdNormalErrorFunctionAVX_p = ::std::shared_ptr< SimdNormalErrorFunctionAVX >

using	SimdNormalErrorFunctionAVX_u = ::std::unique_ptr< SimdNormalErrorFunctionAVX >

using	SimdNormalErrorFunctionAVX_w = ::std::weak_ptr< SimdNormalErrorFunctionAVX >

using	SimdNormalErrorFunctionAVX_const_p = ::std::shared_ptr< const SimdNormalErrorFunctionAVX >

using	SimdNormalErrorFunctionAVX_const_u = ::std::unique_ptr< const SimdNormalErrorFunctionAVX >

using	SimdNormalErrorFunctionAVX_const_w = ::std::weak_ptr< const SimdNormalErrorFunctionAVX >

using	SimdPlaneErrorFunctionAVX_p = ::std::shared_ptr< SimdPlaneErrorFunctionAVX >

using	SimdPlaneErrorFunctionAVX_u = ::std::unique_ptr< SimdPlaneErrorFunctionAVX >

using	SimdPlaneErrorFunctionAVX_w = ::std::weak_ptr< SimdPlaneErrorFunctionAVX >

using	SimdPlaneErrorFunctionAVX_const_p = ::std::shared_ptr< const SimdPlaneErrorFunctionAVX >

using	SimdPlaneErrorFunctionAVX_const_u = ::std::unique_ptr< const SimdPlaneErrorFunctionAVX >

using	SimdPlaneErrorFunctionAVX_const_w = ::std::weak_ptr< const SimdPlaneErrorFunctionAVX >

using	SimdPositionErrorFunctionAVX_p = ::std::shared_ptr< SimdPositionErrorFunctionAVX >

using	SimdPositionErrorFunctionAVX_u = ::std::unique_ptr< SimdPositionErrorFunctionAVX >

using	SimdPositionErrorFunctionAVX_w = ::std::weak_ptr< SimdPositionErrorFunctionAVX >

using	SimdPositionErrorFunctionAVX_const_p = ::std::shared_ptr< const SimdPositionErrorFunctionAVX >

using	SimdPositionErrorFunctionAVX_const_u = ::std::unique_ptr< const SimdPositionErrorFunctionAVX >

using	SimdPositionErrorFunctionAVX_const_w = ::std::weak_ptr< const SimdPositionErrorFunctionAVX >

using	AimDirErrorFunction = AimDirErrorFunctionT< float >

using	AimDirErrorFunctiond = AimDirErrorFunctionT< double >

using	AimDirErrorFunction_p = ::std::shared_ptr< AimDirErrorFunction >

using	AimDirErrorFunction_u = ::std::unique_ptr< AimDirErrorFunction >

using	AimDirErrorFunction_w = ::std::weak_ptr< AimDirErrorFunction >

using	AimDirErrorFunction_const_p = ::std::shared_ptr< const AimDirErrorFunction >

using	AimDirErrorFunction_const_u = ::std::unique_ptr< const AimDirErrorFunction >

using	AimDirErrorFunction_const_w = ::std::weak_ptr< const AimDirErrorFunction >

using	AimDirErrorFunctiond_p = ::std::shared_ptr< AimDirErrorFunctiond >

using	AimDirErrorFunctiond_u = ::std::unique_ptr< AimDirErrorFunctiond >

using	AimDirErrorFunctiond_w = ::std::weak_ptr< AimDirErrorFunctiond >

using	AimDirErrorFunctiond_const_p = ::std::shared_ptr< const AimDirErrorFunctiond >

using	AimDirErrorFunctiond_const_u = ::std::unique_ptr< const AimDirErrorFunctiond >

using	AimDirErrorFunctiond_const_w = ::std::weak_ptr< const AimDirErrorFunctiond >

using	AimDistErrorFunction = AimDistErrorFunctionT< float >

using	AimDistErrorFunctiond = AimDistErrorFunctionT< double >

using	AimDistErrorFunction_p = ::std::shared_ptr< AimDistErrorFunction >

using	AimDistErrorFunction_u = ::std::unique_ptr< AimDistErrorFunction >

using	AimDistErrorFunction_w = ::std::weak_ptr< AimDistErrorFunction >

using	AimDistErrorFunction_const_p = ::std::shared_ptr< const AimDistErrorFunction >

using	AimDistErrorFunction_const_u = ::std::unique_ptr< const AimDistErrorFunction >

using	AimDistErrorFunction_const_w = ::std::weak_ptr< const AimDistErrorFunction >

using	AimDistErrorFunctiond_p = ::std::shared_ptr< AimDistErrorFunctiond >

using	AimDistErrorFunctiond_u = ::std::unique_ptr< AimDistErrorFunctiond >

using	AimDistErrorFunctiond_w = ::std::weak_ptr< AimDistErrorFunctiond >

using	AimDistErrorFunctiond_const_p = ::std::shared_ptr< const AimDistErrorFunctiond >

using	AimDistErrorFunctiond_const_u = ::std::unique_ptr< const AimDistErrorFunctiond >

using	AimDistErrorFunctiond_const_w = ::std::weak_ptr< const AimDistErrorFunctiond >

using	CollisionErrorFunction = CollisionErrorFunctionT< float >

using	CollisionErrorFunctiond = CollisionErrorFunctionT< double >

using	CollisionErrorFunction_p = ::std::shared_ptr< CollisionErrorFunction >

using	CollisionErrorFunction_u = ::std::unique_ptr< CollisionErrorFunction >

using	CollisionErrorFunction_w = ::std::weak_ptr< CollisionErrorFunction >

using	CollisionErrorFunction_const_p = ::std::shared_ptr< const CollisionErrorFunction >

using	CollisionErrorFunction_const_u = ::std::unique_ptr< const CollisionErrorFunction >

using	CollisionErrorFunction_const_w = ::std::weak_ptr< const CollisionErrorFunction >

using	CollisionErrorFunctiond_p = ::std::shared_ptr< CollisionErrorFunctiond >

using	CollisionErrorFunctiond_u = ::std::unique_ptr< CollisionErrorFunctiond >

using	CollisionErrorFunctiond_w = ::std::weak_ptr< CollisionErrorFunctiond >

using	CollisionErrorFunctiond_const_p = ::std::shared_ptr< const CollisionErrorFunctiond >

using	CollisionErrorFunctiond_const_u = ::std::unique_ptr< const CollisionErrorFunctiond >

using	CollisionErrorFunctiond_const_w = ::std::weak_ptr< const CollisionErrorFunctiond >

using	CollisionErrorFunctionStateless = CollisionErrorFunctionStatelessT< float >

using	CollisionErrorFunctionStatelessd = CollisionErrorFunctionStatelessT< double >

using	CollisionErrorFunctionStateless_p = ::std::shared_ptr< CollisionErrorFunctionStateless >

using	CollisionErrorFunctionStateless_u = ::std::unique_ptr< CollisionErrorFunctionStateless >

using	CollisionErrorFunctionStateless_w = ::std::weak_ptr< CollisionErrorFunctionStateless >

using	CollisionErrorFunctionStateless_const_p = ::std::shared_ptr< const CollisionErrorFunctionStateless >

using	CollisionErrorFunctionStateless_const_u = ::std::unique_ptr< const CollisionErrorFunctionStateless >

using	CollisionErrorFunctionStateless_const_w = ::std::weak_ptr< const CollisionErrorFunctionStateless >

using	CollisionErrorFunctionStatelessd_p = ::std::shared_ptr< CollisionErrorFunctionStatelessd >

using	CollisionErrorFunctionStatelessd_u = ::std::unique_ptr< CollisionErrorFunctionStatelessd >

using	CollisionErrorFunctionStatelessd_w = ::std::weak_ptr< CollisionErrorFunctionStatelessd >

using	CollisionErrorFunctionStatelessd_const_p = ::std::shared_ptr< const CollisionErrorFunctionStatelessd >

using	CollisionErrorFunctionStatelessd_const_u = ::std::unique_ptr< const CollisionErrorFunctionStatelessd >

using	CollisionErrorFunctionStatelessd_const_w = ::std::weak_ptr< const CollisionErrorFunctionStatelessd >

using	DistanceErrorFunction = DistanceErrorFunctionT< float >

using	DistanceErrorFunctiond = DistanceErrorFunctionT< double >

using	DistanceErrorFunction_p = ::std::shared_ptr< DistanceErrorFunction >

using	DistanceErrorFunction_u = ::std::unique_ptr< DistanceErrorFunction >

using	DistanceErrorFunction_w = ::std::weak_ptr< DistanceErrorFunction >

using	DistanceErrorFunction_const_p = ::std::shared_ptr< const DistanceErrorFunction >

using	DistanceErrorFunction_const_u = ::std::unique_ptr< const DistanceErrorFunction >

using	DistanceErrorFunction_const_w = ::std::weak_ptr< const DistanceErrorFunction >

using	DistanceErrorFunctiond_p = ::std::shared_ptr< DistanceErrorFunctiond >

using	DistanceErrorFunctiond_u = ::std::unique_ptr< DistanceErrorFunctiond >

using	DistanceErrorFunctiond_w = ::std::weak_ptr< DistanceErrorFunctiond >

using	DistanceErrorFunctiond_const_p = ::std::shared_ptr< const DistanceErrorFunctiond >

using	DistanceErrorFunctiond_const_u = ::std::unique_ptr< const DistanceErrorFunctiond >

using	DistanceErrorFunctiond_const_w = ::std::weak_ptr< const DistanceErrorFunctiond >

using	FixedAxisAngleErrorFunction = FixedAxisAngleErrorFunctionT< float >

using	FixedAxisAngleErrorFunctiond = FixedAxisAngleErrorFunctionT< double >

using	FixedAxisAngleErrorFunction_p = ::std::shared_ptr< FixedAxisAngleErrorFunction >

using	FixedAxisAngleErrorFunction_u = ::std::unique_ptr< FixedAxisAngleErrorFunction >

using	FixedAxisAngleErrorFunction_w = ::std::weak_ptr< FixedAxisAngleErrorFunction >

using	FixedAxisAngleErrorFunction_const_p = ::std::shared_ptr< const FixedAxisAngleErrorFunction >

using	FixedAxisAngleErrorFunction_const_u = ::std::unique_ptr< const FixedAxisAngleErrorFunction >

using	FixedAxisAngleErrorFunction_const_w = ::std::weak_ptr< const FixedAxisAngleErrorFunction >

using	FixedAxisAngleErrorFunctiond_p = ::std::shared_ptr< FixedAxisAngleErrorFunctiond >

using	FixedAxisAngleErrorFunctiond_u = ::std::unique_ptr< FixedAxisAngleErrorFunctiond >

using	FixedAxisAngleErrorFunctiond_w = ::std::weak_ptr< FixedAxisAngleErrorFunctiond >

using	FixedAxisAngleErrorFunctiond_const_p = ::std::shared_ptr< const FixedAxisAngleErrorFunctiond >

using	FixedAxisAngleErrorFunctiond_const_u = ::std::unique_ptr< const FixedAxisAngleErrorFunctiond >

using	FixedAxisAngleErrorFunctiond_const_w = ::std::weak_ptr< const FixedAxisAngleErrorFunctiond >

using	FixedAxisCosErrorFunction = FixedAxisCosErrorFunctionT< float >

using	FixedAxisCosErrorFunctiond = FixedAxisCosErrorFunctionT< double >

using	FixedAxisCosErrorFunction_p = ::std::shared_ptr< FixedAxisCosErrorFunction >

using	FixedAxisCosErrorFunction_u = ::std::unique_ptr< FixedAxisCosErrorFunction >

using	FixedAxisCosErrorFunction_w = ::std::weak_ptr< FixedAxisCosErrorFunction >

using	FixedAxisCosErrorFunction_const_p = ::std::shared_ptr< const FixedAxisCosErrorFunction >

using	FixedAxisCosErrorFunction_const_u = ::std::unique_ptr< const FixedAxisCosErrorFunction >

using	FixedAxisCosErrorFunction_const_w = ::std::weak_ptr< const FixedAxisCosErrorFunction >

using	FixedAxisCosErrorFunctiond_p = ::std::shared_ptr< FixedAxisCosErrorFunctiond >

using	FixedAxisCosErrorFunctiond_u = ::std::unique_ptr< FixedAxisCosErrorFunctiond >

using	FixedAxisCosErrorFunctiond_w = ::std::weak_ptr< FixedAxisCosErrorFunctiond >

using	FixedAxisCosErrorFunctiond_const_p = ::std::shared_ptr< const FixedAxisCosErrorFunctiond >

using	FixedAxisCosErrorFunctiond_const_u = ::std::unique_ptr< const FixedAxisCosErrorFunctiond >

using	FixedAxisCosErrorFunctiond_const_w = ::std::weak_ptr< const FixedAxisCosErrorFunctiond >

using	FixedAxisDiffErrorFunction = FixedAxisDiffErrorFunctionT< float >

using	FixedAxisDiffErrorFunctiond = FixedAxisDiffErrorFunctionT< double >

using	FixedAxisDiffErrorFunction_p = ::std::shared_ptr< FixedAxisDiffErrorFunction >

using	FixedAxisDiffErrorFunction_u = ::std::unique_ptr< FixedAxisDiffErrorFunction >

using	FixedAxisDiffErrorFunction_w = ::std::weak_ptr< FixedAxisDiffErrorFunction >

using	FixedAxisDiffErrorFunction_const_p = ::std::shared_ptr< const FixedAxisDiffErrorFunction >

using	FixedAxisDiffErrorFunction_const_u = ::std::unique_ptr< const FixedAxisDiffErrorFunction >

using	FixedAxisDiffErrorFunction_const_w = ::std::weak_ptr< const FixedAxisDiffErrorFunction >

using	FixedAxisDiffErrorFunctiond_p = ::std::shared_ptr< FixedAxisDiffErrorFunctiond >

using	FixedAxisDiffErrorFunctiond_u = ::std::unique_ptr< FixedAxisDiffErrorFunctiond >

using	FixedAxisDiffErrorFunctiond_w = ::std::weak_ptr< FixedAxisDiffErrorFunctiond >

using	FixedAxisDiffErrorFunctiond_const_p = ::std::shared_ptr< const FixedAxisDiffErrorFunctiond >

using	FixedAxisDiffErrorFunctiond_const_u = ::std::unique_ptr< const FixedAxisDiffErrorFunctiond >

using	FixedAxisDiffErrorFunctiond_const_w = ::std::weak_ptr< const FixedAxisDiffErrorFunctiond >

using	GaussNewtonSolverQR = GaussNewtonSolverQRT< float >

using	GaussNewtonSolverQRd = GaussNewtonSolverQRT< double >

using	GaussNewtonSolverQR_p = ::std::shared_ptr< GaussNewtonSolverQR >

using	GaussNewtonSolverQR_u = ::std::unique_ptr< GaussNewtonSolverQR >

using	GaussNewtonSolverQR_w = ::std::weak_ptr< GaussNewtonSolverQR >

using	GaussNewtonSolverQR_const_p = ::std::shared_ptr< const GaussNewtonSolverQR >

using	GaussNewtonSolverQR_const_u = ::std::unique_ptr< const GaussNewtonSolverQR >

using	GaussNewtonSolverQR_const_w = ::std::weak_ptr< const GaussNewtonSolverQR >

using	GaussNewtonSolverQRd_p = ::std::shared_ptr< GaussNewtonSolverQRd >

using	GaussNewtonSolverQRd_u = ::std::unique_ptr< GaussNewtonSolverQRd >

using	GaussNewtonSolverQRd_w = ::std::weak_ptr< GaussNewtonSolverQRd >

using	GaussNewtonSolverQRd_const_p = ::std::shared_ptr< const GaussNewtonSolverQRd >

using	GaussNewtonSolverQRd_const_u = ::std::unique_ptr< const GaussNewtonSolverQRd >

using	GaussNewtonSolverQRd_const_w = ::std::weak_ptr< const GaussNewtonSolverQRd >

using	HeightErrorFunction = HeightErrorFunctionT< float >

using	HeightErrorFunctiond = HeightErrorFunctionT< double >

using	HeightErrorFunction_p = ::std::shared_ptr< HeightErrorFunction >

using	HeightErrorFunction_u = ::std::unique_ptr< HeightErrorFunction >

using	HeightErrorFunction_w = ::std::weak_ptr< HeightErrorFunction >

using	HeightErrorFunction_const_p = ::std::shared_ptr< const HeightErrorFunction >

using	HeightErrorFunction_const_u = ::std::unique_ptr< const HeightErrorFunction >

using	HeightErrorFunction_const_w = ::std::weak_ptr< const HeightErrorFunction >

using	HeightErrorFunctiond_p = ::std::shared_ptr< HeightErrorFunctiond >

using	HeightErrorFunctiond_u = ::std::unique_ptr< HeightErrorFunctiond >

using	HeightErrorFunctiond_w = ::std::weak_ptr< HeightErrorFunctiond >

using	HeightErrorFunctiond_const_p = ::std::shared_ptr< const HeightErrorFunctiond >

using	HeightErrorFunctiond_const_u = ::std::unique_ptr< const HeightErrorFunctiond >

using	HeightErrorFunctiond_const_w = ::std::weak_ptr< const HeightErrorFunctiond >

using	LimitErrorFunction = LimitErrorFunctionT< float >

using	LimitErrorFunctiond = LimitErrorFunctionT< double >

using	LimitErrorFunction_p = ::std::shared_ptr< LimitErrorFunction >

using	LimitErrorFunction_u = ::std::unique_ptr< LimitErrorFunction >

using	LimitErrorFunction_w = ::std::weak_ptr< LimitErrorFunction >

using	LimitErrorFunction_const_p = ::std::shared_ptr< const LimitErrorFunction >

using	LimitErrorFunction_const_u = ::std::unique_ptr< const LimitErrorFunction >

using	LimitErrorFunction_const_w = ::std::weak_ptr< const LimitErrorFunction >

using	LimitErrorFunctiond_p = ::std::shared_ptr< LimitErrorFunctiond >

using	LimitErrorFunctiond_u = ::std::unique_ptr< LimitErrorFunctiond >

using	LimitErrorFunctiond_w = ::std::weak_ptr< LimitErrorFunctiond >

using	LimitErrorFunctiond_const_p = ::std::shared_ptr< const LimitErrorFunctiond >

using	LimitErrorFunctiond_const_u = ::std::unique_ptr< const LimitErrorFunctiond >

using	LimitErrorFunctiond_const_w = ::std::weak_ptr< const LimitErrorFunctiond >

using	ModelParametersErrorFunction = ModelParametersErrorFunctionT< float >

using	ModelParametersErrorFunctiond = ModelParametersErrorFunctionT< double >

using	ModelParametersErrorFunction_p = ::std::shared_ptr< ModelParametersErrorFunction >

using	ModelParametersErrorFunction_u = ::std::unique_ptr< ModelParametersErrorFunction >

using	ModelParametersErrorFunction_w = ::std::weak_ptr< ModelParametersErrorFunction >

using	ModelParametersErrorFunction_const_p = ::std::shared_ptr< const ModelParametersErrorFunction >

using	ModelParametersErrorFunction_const_u = ::std::unique_ptr< const ModelParametersErrorFunction >

using	ModelParametersErrorFunction_const_w = ::std::weak_ptr< const ModelParametersErrorFunction >

using	ModelParametersErrorFunctiond_p = ::std::shared_ptr< ModelParametersErrorFunctiond >

using	ModelParametersErrorFunctiond_u = ::std::unique_ptr< ModelParametersErrorFunctiond >

using	ModelParametersErrorFunctiond_w = ::std::weak_ptr< ModelParametersErrorFunctiond >

using	ModelParametersErrorFunctiond_const_p = ::std::shared_ptr< const ModelParametersErrorFunctiond >

using	ModelParametersErrorFunctiond_const_u = ::std::unique_ptr< const ModelParametersErrorFunctiond >

using	ModelParametersErrorFunctiond_const_w = ::std::weak_ptr< const ModelParametersErrorFunctiond >

using	NormalErrorFunction = NormalErrorFunctionT< float >

using	NormalErrorFunctiond = NormalErrorFunctionT< double >

using	NormalErrorFunction_p = ::std::shared_ptr< NormalErrorFunction >

using	NormalErrorFunction_u = ::std::unique_ptr< NormalErrorFunction >

using	NormalErrorFunction_w = ::std::weak_ptr< NormalErrorFunction >

using	NormalErrorFunction_const_p = ::std::shared_ptr< const NormalErrorFunction >

using	NormalErrorFunction_const_u = ::std::unique_ptr< const NormalErrorFunction >

using	NormalErrorFunction_const_w = ::std::weak_ptr< const NormalErrorFunction >

using	NormalErrorFunctiond_p = ::std::shared_ptr< NormalErrorFunctiond >

using	NormalErrorFunctiond_u = ::std::unique_ptr< NormalErrorFunctiond >

using	NormalErrorFunctiond_w = ::std::weak_ptr< NormalErrorFunctiond >

using	NormalErrorFunctiond_const_p = ::std::shared_ptr< const NormalErrorFunctiond >

using	NormalErrorFunctiond_const_u = ::std::unique_ptr< const NormalErrorFunctiond >

using	NormalErrorFunctiond_const_w = ::std::weak_ptr< const NormalErrorFunctiond >

using	OrientationErrorFunction = OrientationErrorFunctionT< float >

using	OrientationErrorFunctiond = OrientationErrorFunctionT< double >

using	OrientationErrorFunction_p = ::std::shared_ptr< OrientationErrorFunction >

using	OrientationErrorFunction_u = ::std::unique_ptr< OrientationErrorFunction >

using	OrientationErrorFunction_w = ::std::weak_ptr< OrientationErrorFunction >

using	OrientationErrorFunction_const_p = ::std::shared_ptr< const OrientationErrorFunction >

using	OrientationErrorFunction_const_u = ::std::unique_ptr< const OrientationErrorFunction >

using	OrientationErrorFunction_const_w = ::std::weak_ptr< const OrientationErrorFunction >

using	OrientationErrorFunctiond_p = ::std::shared_ptr< OrientationErrorFunctiond >

using	OrientationErrorFunctiond_u = ::std::unique_ptr< OrientationErrorFunctiond >

using	OrientationErrorFunctiond_w = ::std::weak_ptr< OrientationErrorFunctiond >

using	OrientationErrorFunctiond_const_p = ::std::shared_ptr< const OrientationErrorFunctiond >

using	OrientationErrorFunctiond_const_u = ::std::unique_ptr< const OrientationErrorFunctiond >

using	OrientationErrorFunctiond_const_w = ::std::weak_ptr< const OrientationErrorFunctiond >

using	PlaneErrorFunction = PlaneErrorFunctionT< float >

using	PlaneErrorFunctiond = PlaneErrorFunctionT< double >

using	PlaneErrorFunction_p = ::std::shared_ptr< PlaneErrorFunction >

using	PlaneErrorFunction_u = ::std::unique_ptr< PlaneErrorFunction >

using	PlaneErrorFunction_w = ::std::weak_ptr< PlaneErrorFunction >

using	PlaneErrorFunction_const_p = ::std::shared_ptr< const PlaneErrorFunction >

using	PlaneErrorFunction_const_u = ::std::unique_ptr< const PlaneErrorFunction >

using	PlaneErrorFunction_const_w = ::std::weak_ptr< const PlaneErrorFunction >

using	PlaneErrorFunctiond_p = ::std::shared_ptr< PlaneErrorFunctiond >

using	PlaneErrorFunctiond_u = ::std::unique_ptr< PlaneErrorFunctiond >

using	PlaneErrorFunctiond_w = ::std::weak_ptr< PlaneErrorFunctiond >

using	PlaneErrorFunctiond_const_p = ::std::shared_ptr< const PlaneErrorFunctiond >

using	PlaneErrorFunctiond_const_u = ::std::unique_ptr< const PlaneErrorFunctiond >

using	PlaneErrorFunctiond_const_w = ::std::weak_ptr< const PlaneErrorFunctiond >

using	PointTriangleVertexErrorFunction = PointTriangleVertexErrorFunctionT< float >

using	PointTriangleVertexErrorFunctiond = PointTriangleVertexErrorFunctionT< double >

using	PointTriangleVertexErrorFunction_p = ::std::shared_ptr< PointTriangleVertexErrorFunction >

using	PointTriangleVertexErrorFunction_u = ::std::unique_ptr< PointTriangleVertexErrorFunction >

using	PointTriangleVertexErrorFunction_w = ::std::weak_ptr< PointTriangleVertexErrorFunction >

using	PointTriangleVertexErrorFunction_const_p = ::std::shared_ptr< const PointTriangleVertexErrorFunction >

using	PointTriangleVertexErrorFunction_const_u = ::std::unique_ptr< const PointTriangleVertexErrorFunction >

using	PointTriangleVertexErrorFunction_const_w = ::std::weak_ptr< const PointTriangleVertexErrorFunction >

using	PointTriangleVertexErrorFunctiond_p = ::std::shared_ptr< PointTriangleVertexErrorFunctiond >

using	PointTriangleVertexErrorFunctiond_u = ::std::unique_ptr< PointTriangleVertexErrorFunctiond >

using	PointTriangleVertexErrorFunctiond_w = ::std::weak_ptr< PointTriangleVertexErrorFunctiond >

using	PointTriangleVertexErrorFunctiond_const_p = ::std::shared_ptr< const PointTriangleVertexErrorFunctiond >

using	PointTriangleVertexErrorFunctiond_const_u = ::std::unique_ptr< const PointTriangleVertexErrorFunctiond >

using	PointTriangleVertexErrorFunctiond_const_w = ::std::weak_ptr< const PointTriangleVertexErrorFunctiond >

using	PosePriorErrorFunction = PosePriorErrorFunctionT< float >

using	PosePriorErrorFunctiond = PosePriorErrorFunctionT< double >

using	PosePriorErrorFunction_p = ::std::shared_ptr< PosePriorErrorFunction >

using	PosePriorErrorFunction_u = ::std::unique_ptr< PosePriorErrorFunction >

using	PosePriorErrorFunction_w = ::std::weak_ptr< PosePriorErrorFunction >

using	PosePriorErrorFunction_const_p = ::std::shared_ptr< const PosePriorErrorFunction >

using	PosePriorErrorFunction_const_u = ::std::unique_ptr< const PosePriorErrorFunction >

using	PosePriorErrorFunction_const_w = ::std::weak_ptr< const PosePriorErrorFunction >

using	PosePriorErrorFunctiond_p = ::std::shared_ptr< PosePriorErrorFunctiond >

using	PosePriorErrorFunctiond_u = ::std::unique_ptr< PosePriorErrorFunctiond >

using	PosePriorErrorFunctiond_w = ::std::weak_ptr< PosePriorErrorFunctiond >

using	PosePriorErrorFunctiond_const_p = ::std::shared_ptr< const PosePriorErrorFunctiond >

using	PosePriorErrorFunctiond_const_u = ::std::unique_ptr< const PosePriorErrorFunctiond >

using	PosePriorErrorFunctiond_const_w = ::std::weak_ptr< const PosePriorErrorFunctiond >

using	PoseTransformSolver = PoseTransformSolverT< float >

using	PoseTransformSolverd = PoseTransformSolverT< double >

using	PoseTransformSolver_p = ::std::shared_ptr< PoseTransformSolver >

using	PoseTransformSolver_u = ::std::unique_ptr< PoseTransformSolver >

using	PoseTransformSolver_w = ::std::weak_ptr< PoseTransformSolver >

using	PoseTransformSolver_const_p = ::std::shared_ptr< const PoseTransformSolver >

using	PoseTransformSolver_const_u = ::std::unique_ptr< const PoseTransformSolver >

using	PoseTransformSolver_const_w = ::std::weak_ptr< const PoseTransformSolver >

using	PoseTransformSolverd_p = ::std::shared_ptr< PoseTransformSolverd >

using	PoseTransformSolverd_u = ::std::unique_ptr< PoseTransformSolverd >

using	PoseTransformSolverd_w = ::std::weak_ptr< PoseTransformSolverd >

using	PoseTransformSolverd_const_p = ::std::shared_ptr< const PoseTransformSolverd >

using	PoseTransformSolverd_const_u = ::std::unique_ptr< const PoseTransformSolverd >

using	PoseTransformSolverd_const_w = ::std::weak_ptr< const PoseTransformSolverd >

using	PositionErrorFunction = PositionErrorFunctionT< float >

using	PositionErrorFunctiond = PositionErrorFunctionT< double >

using	PositionErrorFunction_p = ::std::shared_ptr< PositionErrorFunction >

using	PositionErrorFunction_u = ::std::unique_ptr< PositionErrorFunction >

using	PositionErrorFunction_w = ::std::weak_ptr< PositionErrorFunction >

using	PositionErrorFunction_const_p = ::std::shared_ptr< const PositionErrorFunction >

using	PositionErrorFunction_const_u = ::std::unique_ptr< const PositionErrorFunction >

using	PositionErrorFunction_const_w = ::std::weak_ptr< const PositionErrorFunction >

using	PositionErrorFunctiond_p = ::std::shared_ptr< PositionErrorFunctiond >

using	PositionErrorFunctiond_u = ::std::unique_ptr< PositionErrorFunctiond >

using	PositionErrorFunctiond_w = ::std::weak_ptr< PositionErrorFunctiond >

using	PositionErrorFunctiond_const_p = ::std::shared_ptr< const PositionErrorFunctiond >

using	PositionErrorFunctiond_const_u = ::std::unique_ptr< const PositionErrorFunctiond >

using	PositionErrorFunctiond_const_w = ::std::weak_ptr< const PositionErrorFunctiond >

using	ProjectionErrorFunction = ProjectionErrorFunctionT< float >

using	ProjectionErrorFunctiond = ProjectionErrorFunctionT< double >

using	ProjectionErrorFunction_p = ::std::shared_ptr< ProjectionErrorFunction >

using	ProjectionErrorFunction_u = ::std::unique_ptr< ProjectionErrorFunction >

using	ProjectionErrorFunction_w = ::std::weak_ptr< ProjectionErrorFunction >

using	ProjectionErrorFunction_const_p = ::std::shared_ptr< const ProjectionErrorFunction >

using	ProjectionErrorFunction_const_u = ::std::unique_ptr< const ProjectionErrorFunction >

using	ProjectionErrorFunction_const_w = ::std::weak_ptr< const ProjectionErrorFunction >

using	ProjectionErrorFunctiond_p = ::std::shared_ptr< ProjectionErrorFunctiond >

using	ProjectionErrorFunctiond_u = ::std::unique_ptr< ProjectionErrorFunctiond >

using	ProjectionErrorFunctiond_w = ::std::weak_ptr< ProjectionErrorFunctiond >

using	ProjectionErrorFunctiond_const_p = ::std::shared_ptr< const ProjectionErrorFunctiond >

using	ProjectionErrorFunctiond_const_u = ::std::unique_ptr< const ProjectionErrorFunctiond >

using	ProjectionErrorFunctiond_const_w = ::std::weak_ptr< const ProjectionErrorFunctiond >

using	SimdCollisionErrorFunction = SimdCollisionErrorFunctionT< float >

using	SimdCollisionErrorFunctiond = SimdCollisionErrorFunctionT< double >

using	SimdCollisionErrorFunction_p = ::std::shared_ptr< SimdCollisionErrorFunction >

using	SimdCollisionErrorFunction_u = ::std::unique_ptr< SimdCollisionErrorFunction >

using	SimdCollisionErrorFunction_w = ::std::weak_ptr< SimdCollisionErrorFunction >

using	SimdCollisionErrorFunction_const_p = ::std::shared_ptr< const SimdCollisionErrorFunction >

using	SimdCollisionErrorFunction_const_u = ::std::unique_ptr< const SimdCollisionErrorFunction >

using	SimdCollisionErrorFunction_const_w = ::std::weak_ptr< const SimdCollisionErrorFunction >

using	SimdCollisionErrorFunctiond_p = ::std::shared_ptr< SimdCollisionErrorFunctiond >

using	SimdCollisionErrorFunctiond_u = ::std::unique_ptr< SimdCollisionErrorFunctiond >

using	SimdCollisionErrorFunctiond_w = ::std::weak_ptr< SimdCollisionErrorFunctiond >

using	SimdCollisionErrorFunctiond_const_p = ::std::shared_ptr< const SimdCollisionErrorFunctiond >

using	SimdCollisionErrorFunctiond_const_u = ::std::unique_ptr< const SimdCollisionErrorFunctiond >

using	SimdCollisionErrorFunctiond_const_w = ::std::weak_ptr< const SimdCollisionErrorFunctiond >

using	SkeletonErrorFunction = SkeletonErrorFunctionT< float >

using	SkeletonErrorFunctiond = SkeletonErrorFunctionT< double >

using	SkeletonErrorFunction_p = ::std::shared_ptr< SkeletonErrorFunction >

using	SkeletonErrorFunction_u = ::std::unique_ptr< SkeletonErrorFunction >

using	SkeletonErrorFunction_w = ::std::weak_ptr< SkeletonErrorFunction >

using	SkeletonErrorFunction_const_p = ::std::shared_ptr< const SkeletonErrorFunction >

using	SkeletonErrorFunction_const_u = ::std::unique_ptr< const SkeletonErrorFunction >

using	SkeletonErrorFunction_const_w = ::std::weak_ptr< const SkeletonErrorFunction >

using	SkeletonErrorFunctiond_p = ::std::shared_ptr< SkeletonErrorFunctiond >

using	SkeletonErrorFunctiond_u = ::std::unique_ptr< SkeletonErrorFunctiond >

using	SkeletonErrorFunctiond_w = ::std::weak_ptr< SkeletonErrorFunctiond >

using	SkeletonErrorFunctiond_const_p = ::std::shared_ptr< const SkeletonErrorFunctiond >

using	SkeletonErrorFunctiond_const_u = ::std::unique_ptr< const SkeletonErrorFunctiond >

using	SkeletonErrorFunctiond_const_w = ::std::weak_ptr< const SkeletonErrorFunctiond >

using	SkeletonSolverFunction = SkeletonSolverFunctionT< float >

using	SkeletonSolverFunctiond = SkeletonSolverFunctionT< double >

using	SkeletonSolverFunction_p = ::std::shared_ptr< SkeletonSolverFunction >

using	SkeletonSolverFunction_u = ::std::unique_ptr< SkeletonSolverFunction >

using	SkeletonSolverFunction_w = ::std::weak_ptr< SkeletonSolverFunction >

using	SkeletonSolverFunction_const_p = ::std::shared_ptr< const SkeletonSolverFunction >

using	SkeletonSolverFunction_const_u = ::std::unique_ptr< const SkeletonSolverFunction >

using	SkeletonSolverFunction_const_w = ::std::weak_ptr< const SkeletonSolverFunction >

using	SkeletonSolverFunctiond_p = ::std::shared_ptr< SkeletonSolverFunctiond >

using	SkeletonSolverFunctiond_u = ::std::unique_ptr< SkeletonSolverFunctiond >

using	SkeletonSolverFunctiond_w = ::std::weak_ptr< SkeletonSolverFunctiond >

using	SkeletonSolverFunctiond_const_p = ::std::shared_ptr< const SkeletonSolverFunctiond >

using	SkeletonSolverFunctiond_const_u = ::std::unique_ptr< const SkeletonSolverFunctiond >

using	SkeletonSolverFunctiond_const_w = ::std::weak_ptr< const SkeletonSolverFunctiond >

using	SkinnedLocatorErrorFunction = SkinnedLocatorErrorFunctionT< float >

using	SkinnedLocatorErrorFunctiond = SkinnedLocatorErrorFunctionT< double >

using	SkinnedLocatorErrorFunction_p = ::std::shared_ptr< SkinnedLocatorErrorFunction >

using	SkinnedLocatorErrorFunction_u = ::std::unique_ptr< SkinnedLocatorErrorFunction >

using	SkinnedLocatorErrorFunction_w = ::std::weak_ptr< SkinnedLocatorErrorFunction >

using	SkinnedLocatorErrorFunction_const_p = ::std::shared_ptr< const SkinnedLocatorErrorFunction >

using	SkinnedLocatorErrorFunction_const_u = ::std::unique_ptr< const SkinnedLocatorErrorFunction >

using	SkinnedLocatorErrorFunction_const_w = ::std::weak_ptr< const SkinnedLocatorErrorFunction >

using	SkinnedLocatorErrorFunctiond_p = ::std::shared_ptr< SkinnedLocatorErrorFunctiond >

using	SkinnedLocatorErrorFunctiond_u = ::std::unique_ptr< SkinnedLocatorErrorFunctiond >

using	SkinnedLocatorErrorFunctiond_w = ::std::weak_ptr< SkinnedLocatorErrorFunctiond >

using	SkinnedLocatorErrorFunctiond_const_p = ::std::shared_ptr< const SkinnedLocatorErrorFunctiond >

using	SkinnedLocatorErrorFunctiond_const_u = ::std::unique_ptr< const SkinnedLocatorErrorFunctiond >

using	SkinnedLocatorErrorFunctiond_const_w = ::std::weak_ptr< const SkinnedLocatorErrorFunctiond >

using	SkinnedLocatorTriangleErrorFunction = SkinnedLocatorTriangleErrorFunctionT< float >

using	SkinnedLocatorTriangleErrorFunctiond = SkinnedLocatorTriangleErrorFunctionT< double >

using	SkinnedLocatorTriangleErrorFunction_p = ::std::shared_ptr< SkinnedLocatorTriangleErrorFunction >

using	SkinnedLocatorTriangleErrorFunction_u = ::std::unique_ptr< SkinnedLocatorTriangleErrorFunction >

using	SkinnedLocatorTriangleErrorFunction_w = ::std::weak_ptr< SkinnedLocatorTriangleErrorFunction >

using	SkinnedLocatorTriangleErrorFunction_const_p = ::std::shared_ptr< const SkinnedLocatorTriangleErrorFunction >

using	SkinnedLocatorTriangleErrorFunction_const_u = ::std::unique_ptr< const SkinnedLocatorTriangleErrorFunction >

using	SkinnedLocatorTriangleErrorFunction_const_w = ::std::weak_ptr< const SkinnedLocatorTriangleErrorFunction >

using	SkinnedLocatorTriangleErrorFunctiond_p = ::std::shared_ptr< SkinnedLocatorTriangleErrorFunctiond >

using	SkinnedLocatorTriangleErrorFunctiond_u = ::std::unique_ptr< SkinnedLocatorTriangleErrorFunctiond >

using	SkinnedLocatorTriangleErrorFunctiond_w = ::std::weak_ptr< SkinnedLocatorTriangleErrorFunctiond >

using	SkinnedLocatorTriangleErrorFunctiond_const_p = ::std::shared_ptr< const SkinnedLocatorTriangleErrorFunctiond >

using	SkinnedLocatorTriangleErrorFunctiond_const_u = ::std::unique_ptr< const SkinnedLocatorTriangleErrorFunctiond >

using	SkinnedLocatorTriangleErrorFunctiond_const_w = ::std::weak_ptr< const SkinnedLocatorTriangleErrorFunctiond >

using	StateErrorFunction = StateErrorFunctionT< float >

using	StateErrorFunctiond = StateErrorFunctionT< double >

using	StateErrorFunction_p = ::std::shared_ptr< StateErrorFunction >

using	StateErrorFunction_u = ::std::unique_ptr< StateErrorFunction >

using	StateErrorFunction_w = ::std::weak_ptr< StateErrorFunction >

using	StateErrorFunction_const_p = ::std::shared_ptr< const StateErrorFunction >

using	StateErrorFunction_const_u = ::std::unique_ptr< const StateErrorFunction >

using	StateErrorFunction_const_w = ::std::weak_ptr< const StateErrorFunction >

using	StateErrorFunctiond_p = ::std::shared_ptr< StateErrorFunctiond >

using	StateErrorFunctiond_u = ::std::unique_ptr< StateErrorFunctiond >

using	StateErrorFunctiond_w = ::std::weak_ptr< StateErrorFunctiond >

using	StateErrorFunctiond_const_p = ::std::shared_ptr< const StateErrorFunctiond >

using	StateErrorFunctiond_const_u = ::std::unique_ptr< const StateErrorFunctiond >

using	StateErrorFunctiond_const_w = ::std::weak_ptr< const StateErrorFunctiond >

using	TrustRegionQR = TrustRegionQRT< float >

using	TrustRegionQRd = TrustRegionQRT< double >

using	TrustRegionQR_p = ::std::shared_ptr< TrustRegionQR >

using	TrustRegionQR_u = ::std::unique_ptr< TrustRegionQR >

using	TrustRegionQR_w = ::std::weak_ptr< TrustRegionQR >

using	TrustRegionQR_const_p = ::std::shared_ptr< const TrustRegionQR >

using	TrustRegionQR_const_u = ::std::unique_ptr< const TrustRegionQR >

using	TrustRegionQR_const_w = ::std::weak_ptr< const TrustRegionQR >

using	TrustRegionQRd_p = ::std::shared_ptr< TrustRegionQRd >

using	TrustRegionQRd_u = ::std::unique_ptr< TrustRegionQRd >

using	TrustRegionQRd_w = ::std::weak_ptr< TrustRegionQRd >

using	TrustRegionQRd_const_p = ::std::shared_ptr< const TrustRegionQRd >

using	TrustRegionQRd_const_u = ::std::unique_ptr< const TrustRegionQRd >

using	TrustRegionQRd_const_w = ::std::weak_ptr< const TrustRegionQRd >

using	VertexErrorFunction = VertexErrorFunctionT< float >

using	VertexErrorFunctiond = VertexErrorFunctionT< double >

using	VertexErrorFunction_p = ::std::shared_ptr< VertexErrorFunction >

using	VertexErrorFunction_u = ::std::unique_ptr< VertexErrorFunction >

using	VertexErrorFunction_w = ::std::weak_ptr< VertexErrorFunction >

using	VertexErrorFunction_const_p = ::std::shared_ptr< const VertexErrorFunction >

using	VertexErrorFunction_const_u = ::std::unique_ptr< const VertexErrorFunction >

using	VertexErrorFunction_const_w = ::std::weak_ptr< const VertexErrorFunction >

using	VertexErrorFunctiond_p = ::std::shared_ptr< VertexErrorFunctiond >

using	VertexErrorFunctiond_u = ::std::unique_ptr< VertexErrorFunctiond >

using	VertexErrorFunctiond_w = ::std::weak_ptr< VertexErrorFunctiond >

using	VertexErrorFunctiond_const_p = ::std::shared_ptr< const VertexErrorFunctiond >

using	VertexErrorFunctiond_const_u = ::std::unique_ptr< const VertexErrorFunctiond >

using	VertexErrorFunctiond_const_w = ::std::weak_ptr< const VertexErrorFunctiond >

using	VertexProjectionErrorFunction = VertexProjectionErrorFunctionT< float >

using	VertexProjectionErrorFunctiond = VertexProjectionErrorFunctionT< double >

using	VertexProjectionErrorFunction_p = ::std::shared_ptr< VertexProjectionErrorFunction >

using	VertexProjectionErrorFunction_u = ::std::unique_ptr< VertexProjectionErrorFunction >

using	VertexProjectionErrorFunction_w = ::std::weak_ptr< VertexProjectionErrorFunction >

using	VertexProjectionErrorFunction_const_p = ::std::shared_ptr< const VertexProjectionErrorFunction >

using	VertexProjectionErrorFunction_const_u = ::std::unique_ptr< const VertexProjectionErrorFunction >

using	VertexProjectionErrorFunction_const_w = ::std::weak_ptr< const VertexProjectionErrorFunction >

using	VertexProjectionErrorFunctiond_p = ::std::shared_ptr< VertexProjectionErrorFunctiond >

using	VertexProjectionErrorFunctiond_u = ::std::unique_ptr< VertexProjectionErrorFunctiond >

using	VertexProjectionErrorFunctiond_w = ::std::weak_ptr< VertexProjectionErrorFunctiond >

using	VertexProjectionErrorFunctiond_const_p = ::std::shared_ptr< const VertexProjectionErrorFunctiond >

using	VertexProjectionErrorFunctiond_const_u = ::std::unique_ptr< const VertexProjectionErrorFunctiond >

using	VertexProjectionErrorFunctiond_const_w = ::std::weak_ptr< const VertexProjectionErrorFunctiond >

using	VertexVertexDistanceErrorFunction = VertexVertexDistanceErrorFunctionT< float >

using	VertexVertexDistanceErrorFunctiond = VertexVertexDistanceErrorFunctionT< double >

using	VertexVertexDistanceErrorFunction_p = ::std::shared_ptr< VertexVertexDistanceErrorFunction >

using	VertexVertexDistanceErrorFunction_u = ::std::unique_ptr< VertexVertexDistanceErrorFunction >

using	VertexVertexDistanceErrorFunction_w = ::std::weak_ptr< VertexVertexDistanceErrorFunction >

using	VertexVertexDistanceErrorFunction_const_p = ::std::shared_ptr< const VertexVertexDistanceErrorFunction >

using	VertexVertexDistanceErrorFunction_const_u = ::std::unique_ptr< const VertexVertexDistanceErrorFunction >

using	VertexVertexDistanceErrorFunction_const_w = ::std::weak_ptr< const VertexVertexDistanceErrorFunction >

using	VertexVertexDistanceErrorFunctiond_p = ::std::shared_ptr< VertexVertexDistanceErrorFunctiond >

using	VertexVertexDistanceErrorFunctiond_u = ::std::unique_ptr< VertexVertexDistanceErrorFunctiond >

using	VertexVertexDistanceErrorFunctiond_w = ::std::weak_ptr< VertexVertexDistanceErrorFunctiond >

using	VertexVertexDistanceErrorFunctiond_const_p = ::std::shared_ptr< const VertexVertexDistanceErrorFunctiond >

using	VertexVertexDistanceErrorFunctiond_const_u = ::std::unique_ptr< const VertexVertexDistanceErrorFunctiond >

using	VertexVertexDistanceErrorFunctiond_const_w = ::std::weak_ptr< const VertexVertexDistanceErrorFunctiond >

using	MultiposeSolverOptions_p = ::std::shared_ptr< MultiposeSolverOptions >

using	MultiposeSolverOptions_u = ::std::unique_ptr< MultiposeSolverOptions >

using	MultiposeSolverOptions_w = ::std::weak_ptr< MultiposeSolverOptions >

using	MultiposeSolverOptions_const_p = ::std::shared_ptr< const MultiposeSolverOptions >

using	MultiposeSolverOptions_const_u = ::std::unique_ptr< const MultiposeSolverOptions >

using	MultiposeSolverOptions_const_w = ::std::weak_ptr< const MultiposeSolverOptions >

using	SequenceSolverOptions_p = ::std::shared_ptr< SequenceSolverOptions >

using	SequenceSolverOptions_u = ::std::unique_ptr< SequenceSolverOptions >

using	SequenceSolverOptions_w = ::std::weak_ptr< SequenceSolverOptions >

using	SequenceSolverOptions_const_p = ::std::shared_ptr< const SequenceSolverOptions >

using	SequenceSolverOptions_const_u = ::std::unique_ptr< const SequenceSolverOptions >

using	SequenceSolverOptions_const_w = ::std::weak_ptr< const SequenceSolverOptions >

using	SequenceErrorFunction = SequenceErrorFunctionT< float >

using	SequenceErrorFunctiond = SequenceErrorFunctionT< double >

using	SequenceErrorFunction_p = ::std::shared_ptr< SequenceErrorFunction >

using	SequenceErrorFunction_u = ::std::unique_ptr< SequenceErrorFunction >

using	SequenceErrorFunction_w = ::std::weak_ptr< SequenceErrorFunction >

using	SequenceErrorFunction_const_p = ::std::shared_ptr< const SequenceErrorFunction >

using	SequenceErrorFunction_const_u = ::std::unique_ptr< const SequenceErrorFunction >

using	SequenceErrorFunction_const_w = ::std::weak_ptr< const SequenceErrorFunction >

using	SequenceErrorFunctiond_p = ::std::shared_ptr< SequenceErrorFunctiond >

using	SequenceErrorFunctiond_u = ::std::unique_ptr< SequenceErrorFunctiond >

using	SequenceErrorFunctiond_w = ::std::weak_ptr< SequenceErrorFunctiond >

using	SequenceErrorFunctiond_const_p = ::std::shared_ptr< const SequenceErrorFunctiond >

using	SequenceErrorFunctiond_const_u = ::std::unique_ptr< const SequenceErrorFunctiond >

using	SequenceErrorFunctiond_const_w = ::std::weak_ptr< const SequenceErrorFunctiond >

using	ModelParametersSequenceErrorFunction = ModelParametersSequenceErrorFunctionT< float >

using	ModelParametersSequenceErrorFunctiond = ModelParametersSequenceErrorFunctionT< double >

using	ModelParametersSequenceErrorFunction_p = ::std::shared_ptr< ModelParametersSequenceErrorFunction >

using	ModelParametersSequenceErrorFunction_u = ::std::unique_ptr< ModelParametersSequenceErrorFunction >

using	ModelParametersSequenceErrorFunction_w = ::std::weak_ptr< ModelParametersSequenceErrorFunction >

using	ModelParametersSequenceErrorFunction_const_p = ::std::shared_ptr< const ModelParametersSequenceErrorFunction >

using	ModelParametersSequenceErrorFunction_const_u = ::std::unique_ptr< const ModelParametersSequenceErrorFunction >

using	ModelParametersSequenceErrorFunction_const_w = ::std::weak_ptr< const ModelParametersSequenceErrorFunction >

using	ModelParametersSequenceErrorFunctiond_p = ::std::shared_ptr< ModelParametersSequenceErrorFunctiond >

using	ModelParametersSequenceErrorFunctiond_u = ::std::unique_ptr< ModelParametersSequenceErrorFunctiond >

using	ModelParametersSequenceErrorFunctiond_w = ::std::weak_ptr< ModelParametersSequenceErrorFunctiond >

using	ModelParametersSequenceErrorFunctiond_const_p = ::std::shared_ptr< const ModelParametersSequenceErrorFunctiond >

using	ModelParametersSequenceErrorFunctiond_const_u = ::std::unique_ptr< const ModelParametersSequenceErrorFunctiond >

using	ModelParametersSequenceErrorFunctiond_const_w = ::std::weak_ptr< const ModelParametersSequenceErrorFunctiond >

using	MultiposeSolver = MultiposeSolverT< float >

using	MultiposeSolverd = MultiposeSolverT< double >

using	MultiposeSolver_p = ::std::shared_ptr< MultiposeSolver >

using	MultiposeSolver_u = ::std::unique_ptr< MultiposeSolver >

using	MultiposeSolver_w = ::std::weak_ptr< MultiposeSolver >

using	MultiposeSolver_const_p = ::std::shared_ptr< const MultiposeSolver >

using	MultiposeSolver_const_u = ::std::unique_ptr< const MultiposeSolver >

using	MultiposeSolver_const_w = ::std::weak_ptr< const MultiposeSolver >

using	MultiposeSolverd_p = ::std::shared_ptr< MultiposeSolverd >

using	MultiposeSolverd_u = ::std::unique_ptr< MultiposeSolverd >

using	MultiposeSolverd_w = ::std::weak_ptr< MultiposeSolverd >

using	MultiposeSolverd_const_p = ::std::shared_ptr< const MultiposeSolverd >

using	MultiposeSolverd_const_u = ::std::unique_ptr< const MultiposeSolverd >

using	MultiposeSolverd_const_w = ::std::weak_ptr< const MultiposeSolverd >

using	MultiposeSolverFunction = MultiposeSolverFunctionT< float >

using	MultiposeSolverFunctiond = MultiposeSolverFunctionT< double >

using	MultiposeSolverFunction_p = ::std::shared_ptr< MultiposeSolverFunction >

using	MultiposeSolverFunction_u = ::std::unique_ptr< MultiposeSolverFunction >

using	MultiposeSolverFunction_w = ::std::weak_ptr< MultiposeSolverFunction >

using	MultiposeSolverFunction_const_p = ::std::shared_ptr< const MultiposeSolverFunction >

using	MultiposeSolverFunction_const_u = ::std::unique_ptr< const MultiposeSolverFunction >

using	MultiposeSolverFunction_const_w = ::std::weak_ptr< const MultiposeSolverFunction >

using	MultiposeSolverFunctiond_p = ::std::shared_ptr< MultiposeSolverFunctiond >

using	MultiposeSolverFunctiond_u = ::std::unique_ptr< MultiposeSolverFunctiond >

using	MultiposeSolverFunctiond_w = ::std::weak_ptr< MultiposeSolverFunctiond >

using	MultiposeSolverFunctiond_const_p = ::std::shared_ptr< const MultiposeSolverFunctiond >

using	MultiposeSolverFunctiond_const_u = ::std::unique_ptr< const MultiposeSolverFunctiond >

using	MultiposeSolverFunctiond_const_w = ::std::weak_ptr< const MultiposeSolverFunctiond >

using	SequenceSolver = SequenceSolverT< float >

using	SequenceSolverd = SequenceSolverT< double >

using	SequenceSolver_p = ::std::shared_ptr< SequenceSolver >

using	SequenceSolver_u = ::std::unique_ptr< SequenceSolver >

using	SequenceSolver_w = ::std::weak_ptr< SequenceSolver >

using	SequenceSolver_const_p = ::std::shared_ptr< const SequenceSolver >

using	SequenceSolver_const_u = ::std::unique_ptr< const SequenceSolver >

using	SequenceSolver_const_w = ::std::weak_ptr< const SequenceSolver >

using	SequenceSolverd_p = ::std::shared_ptr< SequenceSolverd >

using	SequenceSolverd_u = ::std::unique_ptr< SequenceSolverd >

using	SequenceSolverd_w = ::std::weak_ptr< SequenceSolverd >

using	SequenceSolverd_const_p = ::std::shared_ptr< const SequenceSolverd >

using	SequenceSolverd_const_u = ::std::unique_ptr< const SequenceSolverd >

using	SequenceSolverd_const_w = ::std::weak_ptr< const SequenceSolverd >

using	SequenceSolverFunction = SequenceSolverFunctionT< float >

using	SequenceSolverFunctiond = SequenceSolverFunctionT< double >

using	SequenceSolverFunction_p = ::std::shared_ptr< SequenceSolverFunction >

using	SequenceSolverFunction_u = ::std::unique_ptr< SequenceSolverFunction >

using	SequenceSolverFunction_w = ::std::weak_ptr< SequenceSolverFunction >

using	SequenceSolverFunction_const_p = ::std::shared_ptr< const SequenceSolverFunction >

using	SequenceSolverFunction_const_u = ::std::unique_ptr< const SequenceSolverFunction >

using	SequenceSolverFunction_const_w = ::std::weak_ptr< const SequenceSolverFunction >

using	SequenceSolverFunctiond_p = ::std::shared_ptr< SequenceSolverFunctiond >

using	SequenceSolverFunctiond_u = ::std::unique_ptr< SequenceSolverFunctiond >

using	SequenceSolverFunctiond_w = ::std::weak_ptr< SequenceSolverFunctiond >

using	SequenceSolverFunctiond_const_p = ::std::shared_ptr< const SequenceSolverFunctiond >

using	SequenceSolverFunctiond_const_u = ::std::unique_ptr< const SequenceSolverFunctiond >

using	SequenceSolverFunctiond_const_w = ::std::weak_ptr< const SequenceSolverFunctiond >

using	StateSequenceErrorFunction = StateSequenceErrorFunctionT< float >

using	StateSequenceErrorFunctiond = StateSequenceErrorFunctionT< double >

using	StateSequenceErrorFunction_p = ::std::shared_ptr< StateSequenceErrorFunction >

using	StateSequenceErrorFunction_u = ::std::unique_ptr< StateSequenceErrorFunction >

using	StateSequenceErrorFunction_w = ::std::weak_ptr< StateSequenceErrorFunction >

using	StateSequenceErrorFunction_const_p = ::std::shared_ptr< const StateSequenceErrorFunction >

using	StateSequenceErrorFunction_const_u = ::std::unique_ptr< const StateSequenceErrorFunction >

using	StateSequenceErrorFunction_const_w = ::std::weak_ptr< const StateSequenceErrorFunction >

using	StateSequenceErrorFunctiond_p = ::std::shared_ptr< StateSequenceErrorFunctiond >

using	StateSequenceErrorFunctiond_u = ::std::unique_ptr< StateSequenceErrorFunctiond >

using	StateSequenceErrorFunctiond_w = ::std::weak_ptr< StateSequenceErrorFunctiond >

using	StateSequenceErrorFunctiond_const_p = ::std::shared_ptr< const StateSequenceErrorFunctiond >

using	StateSequenceErrorFunctiond_const_u = ::std::unique_ptr< const StateSequenceErrorFunctiond >

using	StateSequenceErrorFunctiond_const_w = ::std::weak_ptr< const StateSequenceErrorFunctiond >

using	VertexSequenceErrorFunction = VertexSequenceErrorFunctionT< float >

using	VertexSequenceErrorFunctiond = VertexSequenceErrorFunctionT< double >

using	VertexSequenceErrorFunction_p = ::std::shared_ptr< VertexSequenceErrorFunction >

using	VertexSequenceErrorFunction_u = ::std::unique_ptr< VertexSequenceErrorFunction >

using	VertexSequenceErrorFunction_w = ::std::weak_ptr< VertexSequenceErrorFunction >

using	VertexSequenceErrorFunction_const_p = ::std::shared_ptr< const VertexSequenceErrorFunction >

using	VertexSequenceErrorFunction_const_u = ::std::unique_ptr< const VertexSequenceErrorFunction >

using	VertexSequenceErrorFunction_const_w = ::std::weak_ptr< const VertexSequenceErrorFunction >

using	VertexSequenceErrorFunctiond_p = ::std::shared_ptr< VertexSequenceErrorFunctiond >

using	VertexSequenceErrorFunctiond_u = ::std::unique_ptr< VertexSequenceErrorFunctiond >

using	VertexSequenceErrorFunctiond_w = ::std::weak_ptr< VertexSequenceErrorFunctiond >

using	VertexSequenceErrorFunctiond_const_p = ::std::shared_ptr< const VertexSequenceErrorFunctiond >

using	VertexSequenceErrorFunctiond_const_u = ::std::unique_ptr< const VertexSequenceErrorFunctiond >

using	VertexSequenceErrorFunctiond_const_w = ::std::weak_ptr< const VertexSequenceErrorFunctiond >

using	ErrorFunctionDerivatives = ErrorFunctionDerivativesT< float >

using	ErrorFunctionDerivativesd = ErrorFunctionDerivativesT< double >

using	ErrorFunctionDerivatives_p = ::std::shared_ptr< ErrorFunctionDerivatives >

using	ErrorFunctionDerivatives_u = ::std::unique_ptr< ErrorFunctionDerivatives >

using	ErrorFunctionDerivatives_w = ::std::weak_ptr< ErrorFunctionDerivatives >

using	ErrorFunctionDerivatives_const_p = ::std::shared_ptr< const ErrorFunctionDerivatives >

using	ErrorFunctionDerivatives_const_u = ::std::unique_ptr< const ErrorFunctionDerivatives >

using	ErrorFunctionDerivatives_const_w = ::std::weak_ptr< const ErrorFunctionDerivatives >

using	ErrorFunctionDerivativesd_p = ::std::shared_ptr< ErrorFunctionDerivativesd >

using	ErrorFunctionDerivativesd_u = ::std::unique_ptr< ErrorFunctionDerivativesd >

using	ErrorFunctionDerivativesd_w = ::std::weak_ptr< ErrorFunctionDerivativesd >

using	ErrorFunctionDerivativesd_const_p = ::std::shared_ptr< const ErrorFunctionDerivativesd >

using	ErrorFunctionDerivativesd_const_u = ::std::unique_ptr< const ErrorFunctionDerivativesd >

using	ErrorFunctionDerivativesd_const_w = ::std::weak_ptr< const ErrorFunctionDerivativesd >

using	OrientationConstraint = OrientationConstraintT< float >

using	OrientationConstraintd = OrientationConstraintT< double >

using	OrientationConstraint_p = ::std::shared_ptr< OrientationConstraint >

using	OrientationConstraint_u = ::std::unique_ptr< OrientationConstraint >

using	OrientationConstraint_w = ::std::weak_ptr< OrientationConstraint >

using	OrientationConstraint_const_p = ::std::shared_ptr< const OrientationConstraint >

using	OrientationConstraint_const_u = ::std::unique_ptr< const OrientationConstraint >

using	OrientationConstraint_const_w = ::std::weak_ptr< const OrientationConstraint >

using	OrientationConstraintd_p = ::std::shared_ptr< OrientationConstraintd >

using	OrientationConstraintd_u = ::std::unique_ptr< OrientationConstraintd >

using	OrientationConstraintd_w = ::std::weak_ptr< OrientationConstraintd >

using	OrientationConstraintd_const_p = ::std::shared_ptr< const OrientationConstraintd >

using	OrientationConstraintd_const_u = ::std::unique_ptr< const OrientationConstraintd >

using	OrientationConstraintd_const_w = ::std::weak_ptr< const OrientationConstraintd >

using	OrientationConstraintState = OrientationConstraintStateT< float >

using	OrientationConstraintStated = OrientationConstraintStateT< double >

using	OrientationConstraintState_p = ::std::shared_ptr< OrientationConstraintState >

using	OrientationConstraintState_u = ::std::unique_ptr< OrientationConstraintState >

using	OrientationConstraintState_w = ::std::weak_ptr< OrientationConstraintState >

using	OrientationConstraintState_const_p = ::std::shared_ptr< const OrientationConstraintState >

using	OrientationConstraintState_const_u = ::std::unique_ptr< const OrientationConstraintState >

using	OrientationConstraintState_const_w = ::std::weak_ptr< const OrientationConstraintState >

using	OrientationConstraintStated_p = ::std::shared_ptr< OrientationConstraintStated >

using	OrientationConstraintStated_u = ::std::unique_ptr< OrientationConstraintStated >

using	OrientationConstraintStated_w = ::std::weak_ptr< OrientationConstraintStated >

using	OrientationConstraintStated_const_p = ::std::shared_ptr< const OrientationConstraintStated >

using	OrientationConstraintStated_const_u = ::std::unique_ptr< const OrientationConstraintStated >

using	OrientationConstraintStated_const_w = ::std::weak_ptr< const OrientationConstraintStated >

using	PositionConstraint = PositionConstraintT< float >

using	PositionConstraintd = PositionConstraintT< double >

using	PositionConstraint_p = ::std::shared_ptr< PositionConstraint >

using	PositionConstraint_u = ::std::unique_ptr< PositionConstraint >

using	PositionConstraint_w = ::std::weak_ptr< PositionConstraint >

using	PositionConstraint_const_p = ::std::shared_ptr< const PositionConstraint >

using	PositionConstraint_const_u = ::std::unique_ptr< const PositionConstraint >

using	PositionConstraint_const_w = ::std::weak_ptr< const PositionConstraint >

using	PositionConstraintd_p = ::std::shared_ptr< PositionConstraintd >

using	PositionConstraintd_u = ::std::unique_ptr< PositionConstraintd >

using	PositionConstraintd_w = ::std::weak_ptr< PositionConstraintd >

using	PositionConstraintd_const_p = ::std::shared_ptr< const PositionConstraintd >

using	PositionConstraintd_const_u = ::std::unique_ptr< const PositionConstraintd >

using	PositionConstraintd_const_w = ::std::weak_ptr< const PositionConstraintd >

using	PositionConstraintState = PositionConstraintStateT< float >

using	PositionConstraintStated = PositionConstraintStateT< double >

using	PositionConstraintState_p = ::std::shared_ptr< PositionConstraintState >

using	PositionConstraintState_u = ::std::unique_ptr< PositionConstraintState >

using	PositionConstraintState_w = ::std::weak_ptr< PositionConstraintState >

using	PositionConstraintState_const_p = ::std::shared_ptr< const PositionConstraintState >

using	PositionConstraintState_const_u = ::std::unique_ptr< const PositionConstraintState >

using	PositionConstraintState_const_w = ::std::weak_ptr< const PositionConstraintState >

using	PositionConstraintStated_p = ::std::shared_ptr< PositionConstraintStated >

using	PositionConstraintStated_u = ::std::unique_ptr< PositionConstraintStated >

using	PositionConstraintStated_w = ::std::weak_ptr< PositionConstraintStated >

using	PositionConstraintStated_const_p = ::std::shared_ptr< const PositionConstraintStated >

using	PositionConstraintStated_const_u = ::std::unique_ptr< const PositionConstraintStated >

using	PositionConstraintStated_const_w = ::std::weak_ptr< const PositionConstraintStated >

using	FullyDifferentiableDistanceErrorFunction = FullyDifferentiableDistanceErrorFunctionT< float >

using	FullyDifferentiableDistanceErrorFunctiond = FullyDifferentiableDistanceErrorFunctionT< double >

using	FullyDifferentiableDistanceErrorFunction_p = ::std::shared_ptr< FullyDifferentiableDistanceErrorFunction >

using	FullyDifferentiableDistanceErrorFunction_u = ::std::unique_ptr< FullyDifferentiableDistanceErrorFunction >

using	FullyDifferentiableDistanceErrorFunction_w = ::std::weak_ptr< FullyDifferentiableDistanceErrorFunction >

using	FullyDifferentiableDistanceErrorFunction_const_p = ::std::shared_ptr< const FullyDifferentiableDistanceErrorFunction >

using	FullyDifferentiableDistanceErrorFunction_const_u = ::std::unique_ptr< const FullyDifferentiableDistanceErrorFunction >

using	FullyDifferentiableDistanceErrorFunction_const_w = ::std::weak_ptr< const FullyDifferentiableDistanceErrorFunction >

using	FullyDifferentiableDistanceErrorFunctiond_p = ::std::shared_ptr< FullyDifferentiableDistanceErrorFunctiond >

using	FullyDifferentiableDistanceErrorFunctiond_u = ::std::unique_ptr< FullyDifferentiableDistanceErrorFunctiond >

using	FullyDifferentiableDistanceErrorFunctiond_w = ::std::weak_ptr< FullyDifferentiableDistanceErrorFunctiond >

using	FullyDifferentiableDistanceErrorFunctiond_const_p = ::std::shared_ptr< const FullyDifferentiableDistanceErrorFunctiond >

using	FullyDifferentiableDistanceErrorFunctiond_const_u = ::std::unique_ptr< const FullyDifferentiableDistanceErrorFunctiond >

using	FullyDifferentiableDistanceErrorFunctiond_const_w = ::std::weak_ptr< const FullyDifferentiableDistanceErrorFunctiond >

using	FullyDifferentiableMotionErrorFunction = FullyDifferentiableMotionErrorFunctionT< float >

using	FullyDifferentiableMotionErrorFunctiond = FullyDifferentiableMotionErrorFunctionT< double >

using	FullyDifferentiableMotionErrorFunction_p = ::std::shared_ptr< FullyDifferentiableMotionErrorFunction >

using	FullyDifferentiableMotionErrorFunction_u = ::std::unique_ptr< FullyDifferentiableMotionErrorFunction >

using	FullyDifferentiableMotionErrorFunction_w = ::std::weak_ptr< FullyDifferentiableMotionErrorFunction >

using	FullyDifferentiableMotionErrorFunction_const_p = ::std::shared_ptr< const FullyDifferentiableMotionErrorFunction >

using	FullyDifferentiableMotionErrorFunction_const_u = ::std::unique_ptr< const FullyDifferentiableMotionErrorFunction >

using	FullyDifferentiableMotionErrorFunction_const_w = ::std::weak_ptr< const FullyDifferentiableMotionErrorFunction >

using	FullyDifferentiableMotionErrorFunctiond_p = ::std::shared_ptr< FullyDifferentiableMotionErrorFunctiond >

using	FullyDifferentiableMotionErrorFunctiond_u = ::std::unique_ptr< FullyDifferentiableMotionErrorFunctiond >

using	FullyDifferentiableMotionErrorFunctiond_w = ::std::weak_ptr< FullyDifferentiableMotionErrorFunctiond >

using	FullyDifferentiableMotionErrorFunctiond_const_p = ::std::shared_ptr< const FullyDifferentiableMotionErrorFunctiond >

using	FullyDifferentiableMotionErrorFunctiond_const_u = ::std::unique_ptr< const FullyDifferentiableMotionErrorFunctiond >

using	FullyDifferentiableMotionErrorFunctiond_const_w = ::std::weak_ptr< const FullyDifferentiableMotionErrorFunctiond >

using	FullyDifferentiableOrientationErrorFunction = FullyDifferentiableOrientationErrorFunctionT< float >

using	FullyDifferentiableOrientationErrorFunctiond = FullyDifferentiableOrientationErrorFunctionT< double >

using	FullyDifferentiableOrientationErrorFunction_p = ::std::shared_ptr< FullyDifferentiableOrientationErrorFunction >

using	FullyDifferentiableOrientationErrorFunction_u = ::std::unique_ptr< FullyDifferentiableOrientationErrorFunction >

using	FullyDifferentiableOrientationErrorFunction_w = ::std::weak_ptr< FullyDifferentiableOrientationErrorFunction >

using	FullyDifferentiableOrientationErrorFunction_const_p = ::std::shared_ptr< const FullyDifferentiableOrientationErrorFunction >

using	FullyDifferentiableOrientationErrorFunction_const_u = ::std::unique_ptr< const FullyDifferentiableOrientationErrorFunction >

using	FullyDifferentiableOrientationErrorFunction_const_w = ::std::weak_ptr< const FullyDifferentiableOrientationErrorFunction >

using	FullyDifferentiableOrientationErrorFunctiond_p = ::std::shared_ptr< FullyDifferentiableOrientationErrorFunctiond >

using	FullyDifferentiableOrientationErrorFunctiond_u = ::std::unique_ptr< FullyDifferentiableOrientationErrorFunctiond >

using	FullyDifferentiableOrientationErrorFunctiond_w = ::std::weak_ptr< FullyDifferentiableOrientationErrorFunctiond >

using	FullyDifferentiableOrientationErrorFunctiond_const_p = ::std::shared_ptr< const FullyDifferentiableOrientationErrorFunctiond >

using	FullyDifferentiableOrientationErrorFunctiond_const_u = ::std::unique_ptr< const FullyDifferentiableOrientationErrorFunctiond >

using	FullyDifferentiableOrientationErrorFunctiond_const_w = ::std::weak_ptr< const FullyDifferentiableOrientationErrorFunctiond >

using	FullyDifferentiablePosePriorErrorFunction = FullyDifferentiablePosePriorErrorFunctionT< float >

using	FullyDifferentiablePosePriorErrorFunctiond = FullyDifferentiablePosePriorErrorFunctionT< double >

using	FullyDifferentiablePosePriorErrorFunction_p = ::std::shared_ptr< FullyDifferentiablePosePriorErrorFunction >

using	FullyDifferentiablePosePriorErrorFunction_u = ::std::unique_ptr< FullyDifferentiablePosePriorErrorFunction >

using	FullyDifferentiablePosePriorErrorFunction_w = ::std::weak_ptr< FullyDifferentiablePosePriorErrorFunction >

using	FullyDifferentiablePosePriorErrorFunction_const_p = ::std::shared_ptr< const FullyDifferentiablePosePriorErrorFunction >

using	FullyDifferentiablePosePriorErrorFunction_const_u = ::std::unique_ptr< const FullyDifferentiablePosePriorErrorFunction >

using	FullyDifferentiablePosePriorErrorFunction_const_w = ::std::weak_ptr< const FullyDifferentiablePosePriorErrorFunction >

using	FullyDifferentiablePosePriorErrorFunctiond_p = ::std::shared_ptr< FullyDifferentiablePosePriorErrorFunctiond >

using	FullyDifferentiablePosePriorErrorFunctiond_u = ::std::unique_ptr< FullyDifferentiablePosePriorErrorFunctiond >

using	FullyDifferentiablePosePriorErrorFunctiond_w = ::std::weak_ptr< FullyDifferentiablePosePriorErrorFunctiond >

using	FullyDifferentiablePosePriorErrorFunctiond_const_p = ::std::shared_ptr< const FullyDifferentiablePosePriorErrorFunctiond >

using	FullyDifferentiablePosePriorErrorFunctiond_const_u = ::std::unique_ptr< const FullyDifferentiablePosePriorErrorFunctiond >

using	FullyDifferentiablePosePriorErrorFunctiond_const_w = ::std::weak_ptr< const FullyDifferentiablePosePriorErrorFunctiond >

using	FullyDifferentiablePositionErrorFunction = FullyDifferentiablePositionErrorFunctionT< float >

using	FullyDifferentiablePositionErrorFunctiond = FullyDifferentiablePositionErrorFunctionT< double >

using	FullyDifferentiablePositionErrorFunction_p = ::std::shared_ptr< FullyDifferentiablePositionErrorFunction >

using	FullyDifferentiablePositionErrorFunction_u = ::std::unique_ptr< FullyDifferentiablePositionErrorFunction >

using	FullyDifferentiablePositionErrorFunction_w = ::std::weak_ptr< FullyDifferentiablePositionErrorFunction >

using	FullyDifferentiablePositionErrorFunction_const_p = ::std::shared_ptr< const FullyDifferentiablePositionErrorFunction >

using	FullyDifferentiablePositionErrorFunction_const_u = ::std::unique_ptr< const FullyDifferentiablePositionErrorFunction >

using	FullyDifferentiablePositionErrorFunction_const_w = ::std::weak_ptr< const FullyDifferentiablePositionErrorFunction >

using	FullyDifferentiablePositionErrorFunctiond_p = ::std::shared_ptr< FullyDifferentiablePositionErrorFunctiond >

using	FullyDifferentiablePositionErrorFunctiond_u = ::std::unique_ptr< FullyDifferentiablePositionErrorFunctiond >

using	FullyDifferentiablePositionErrorFunctiond_w = ::std::weak_ptr< FullyDifferentiablePositionErrorFunctiond >

using	FullyDifferentiablePositionErrorFunctiond_const_p = ::std::shared_ptr< const FullyDifferentiablePositionErrorFunctiond >

using	FullyDifferentiablePositionErrorFunctiond_const_u = ::std::unique_ptr< const FullyDifferentiablePositionErrorFunctiond >

using	FullyDifferentiablePositionErrorFunctiond_const_w = ::std::weak_ptr< const FullyDifferentiablePositionErrorFunctiond >

using	FullyDifferentiableProjectionErrorFunction = FullyDifferentiableProjectionErrorFunctionT< float >

using	FullyDifferentiableProjectionErrorFunctiond = FullyDifferentiableProjectionErrorFunctionT< double >

using	FullyDifferentiableProjectionErrorFunction_p = ::std::shared_ptr< FullyDifferentiableProjectionErrorFunction >

using	FullyDifferentiableProjectionErrorFunction_u = ::std::unique_ptr< FullyDifferentiableProjectionErrorFunction >

using	FullyDifferentiableProjectionErrorFunction_w = ::std::weak_ptr< FullyDifferentiableProjectionErrorFunction >

using	FullyDifferentiableProjectionErrorFunction_const_p = ::std::shared_ptr< const FullyDifferentiableProjectionErrorFunction >

using	FullyDifferentiableProjectionErrorFunction_const_u = ::std::unique_ptr< const FullyDifferentiableProjectionErrorFunction >

using	FullyDifferentiableProjectionErrorFunction_const_w = ::std::weak_ptr< const FullyDifferentiableProjectionErrorFunction >

using	FullyDifferentiableProjectionErrorFunctiond_p = ::std::shared_ptr< FullyDifferentiableProjectionErrorFunctiond >

using	FullyDifferentiableProjectionErrorFunctiond_u = ::std::unique_ptr< FullyDifferentiableProjectionErrorFunctiond >

using	FullyDifferentiableProjectionErrorFunctiond_w = ::std::weak_ptr< FullyDifferentiableProjectionErrorFunctiond >

using	FullyDifferentiableProjectionErrorFunctiond_const_p = ::std::shared_ptr< const FullyDifferentiableProjectionErrorFunctiond >

using	FullyDifferentiableProjectionErrorFunctiond_const_u = ::std::unique_ptr< const FullyDifferentiableProjectionErrorFunctiond >

using	FullyDifferentiableProjectionErrorFunctiond_const_w = ::std::weak_ptr< const FullyDifferentiableProjectionErrorFunctiond >

using	FullyDifferentiableSkeletonErrorFunction = FullyDifferentiableSkeletonErrorFunctionT< float >

using	FullyDifferentiableSkeletonErrorFunctiond = FullyDifferentiableSkeletonErrorFunctionT< double >

using	FullyDifferentiableSkeletonErrorFunction_p = ::std::shared_ptr< FullyDifferentiableSkeletonErrorFunction >

using	FullyDifferentiableSkeletonErrorFunction_u = ::std::unique_ptr< FullyDifferentiableSkeletonErrorFunction >

using	FullyDifferentiableSkeletonErrorFunction_w = ::std::weak_ptr< FullyDifferentiableSkeletonErrorFunction >

using	FullyDifferentiableSkeletonErrorFunction_const_p = ::std::shared_ptr< const FullyDifferentiableSkeletonErrorFunction >

using	FullyDifferentiableSkeletonErrorFunction_const_u = ::std::unique_ptr< const FullyDifferentiableSkeletonErrorFunction >

using	FullyDifferentiableSkeletonErrorFunction_const_w = ::std::weak_ptr< const FullyDifferentiableSkeletonErrorFunction >

using	FullyDifferentiableSkeletonErrorFunctiond_p = ::std::shared_ptr< FullyDifferentiableSkeletonErrorFunctiond >

using	FullyDifferentiableSkeletonErrorFunctiond_u = ::std::unique_ptr< FullyDifferentiableSkeletonErrorFunctiond >

using	FullyDifferentiableSkeletonErrorFunctiond_w = ::std::weak_ptr< FullyDifferentiableSkeletonErrorFunctiond >

using	FullyDifferentiableSkeletonErrorFunctiond_const_p = ::std::shared_ptr< const FullyDifferentiableSkeletonErrorFunctiond >

using	FullyDifferentiableSkeletonErrorFunctiond_const_u = ::std::unique_ptr< const FullyDifferentiableSkeletonErrorFunctiond >

using	FullyDifferentiableSkeletonErrorFunctiond_const_w = ::std::weak_ptr< const FullyDifferentiableSkeletonErrorFunctiond >

using	FullyDifferentiableStateErrorFunction = FullyDifferentiableStateErrorFunctionT< float >

using	FullyDifferentiableStateErrorFunctiond = FullyDifferentiableStateErrorFunctionT< double >

using	FullyDifferentiableStateErrorFunction_p = ::std::shared_ptr< FullyDifferentiableStateErrorFunction >

using	FullyDifferentiableStateErrorFunction_u = ::std::unique_ptr< FullyDifferentiableStateErrorFunction >

using	FullyDifferentiableStateErrorFunction_w = ::std::weak_ptr< FullyDifferentiableStateErrorFunction >

using	FullyDifferentiableStateErrorFunction_const_p = ::std::shared_ptr< const FullyDifferentiableStateErrorFunction >

using	FullyDifferentiableStateErrorFunction_const_u = ::std::unique_ptr< const FullyDifferentiableStateErrorFunction >

using	FullyDifferentiableStateErrorFunction_const_w = ::std::weak_ptr< const FullyDifferentiableStateErrorFunction >

using	FullyDifferentiableStateErrorFunctiond_p = ::std::shared_ptr< FullyDifferentiableStateErrorFunctiond >

using	FullyDifferentiableStateErrorFunctiond_u = ::std::unique_ptr< FullyDifferentiableStateErrorFunctiond >

using	FullyDifferentiableStateErrorFunctiond_w = ::std::weak_ptr< FullyDifferentiableStateErrorFunctiond >

using	FullyDifferentiableStateErrorFunctiond_const_p = ::std::shared_ptr< const FullyDifferentiableStateErrorFunctiond >

using	FullyDifferentiableStateErrorFunctiond_const_u = ::std::unique_ptr< const FullyDifferentiableStateErrorFunctiond >

using	FullyDifferentiableStateErrorFunctiond_const_w = ::std::weak_ptr< const FullyDifferentiableStateErrorFunctiond >

using	UnionErrorFunction = UnionErrorFunctionT< float >

using	UnionErrorFunctiond = UnionErrorFunctionT< double >

using	UnionErrorFunction_p = ::std::shared_ptr< UnionErrorFunction >

using	UnionErrorFunction_u = ::std::unique_ptr< UnionErrorFunction >

using	UnionErrorFunction_w = ::std::weak_ptr< UnionErrorFunction >

using	UnionErrorFunction_const_p = ::std::shared_ptr< const UnionErrorFunction >

using	UnionErrorFunction_const_u = ::std::unique_ptr< const UnionErrorFunction >

using	UnionErrorFunction_const_w = ::std::weak_ptr< const UnionErrorFunction >

using	UnionErrorFunctiond_p = ::std::shared_ptr< UnionErrorFunctiond >

using	UnionErrorFunctiond_u = ::std::unique_ptr< UnionErrorFunctiond >

using	UnionErrorFunctiond_w = ::std::weak_ptr< UnionErrorFunctiond >

using	UnionErrorFunctiond_const_p = ::std::shared_ptr< const UnionErrorFunctiond >

using	UnionErrorFunctiond_const_u = ::std::unique_ptr< const UnionErrorFunctiond >

using	UnionErrorFunctiond_const_w = ::std::weak_ptr< const UnionErrorFunctiond >

Enumerations
enum class	LogLevel { Disabled = 0 , Error , Warning , Info , Debug , Trace }
	Logging levels in descending order of verbosity. More...

enum	LimitType { MinMax , MinMaxJoint , MinMaxJointPassive , Linear , LinearJoint , Ellipsoid , HalfPlane , LimitTypeCount }

enum	JointParameterNames { TX = 0 , TY , TZ , RX , RY , RZ , SC }

enum class	RotationErrorType { RotationMatrixDifference , QuaternionLogMap }
	Defines different methods for computing rotation error between two quaternions. More...

enum class	VertexConstraintType { Position , Plane , Normal , SymmetricNormal }

enum class	CharacterFormat : uint8_t { Fbx , Gltf , Usd , Unknown }
	Represents the supported character formats. More...

enum class	KeepLocators { No , Yes }

enum class	LoadBlendShapes { No , Yes }

enum class	GltfFileFormat { Auto = 0 , Binary = 1 , Ascii = 2 }
	File format in which the character is saved. More...

enum class	FbxUpVector { XAxis = 1 , YAxis = 2 , ZAxis = 3 }
	Specifies which canonical axis represents up in the system (typically Y or Z). More...

enum class	FbxFrontVector { ParityEven = 1 , ParityOdd = 2 }
	Vector with origin at the screen pointing toward the camera. More...

enum class	FbxCoordSystem { RightHanded , LeftHanded }
	Specifies the third vector of the system. More...

enum class	UpVector { X = 0 , Y , Z , YNeg }
	This enumeration is used to define the primary up vector directions for various coordinate systems and orientations in a 3D environment. More...

enum class	Unit { M , DM , CM , MM , Unknown }
	An enumeration representing the units of measurement used in marker data files. More...

enum class	LocatorSpace { Local = 0 , Global = 1 }

Functions
void *	aligned_malloc (size_t size, size_t align)

void	aligned_free (void *ptr)

constexpr std::size_t	roundUpToAlignment (std::size_t value, std::size_t alignment)

template<typename T , std::size_t Alignment = alignof(T)>
T *	alignedAlloc (std::size_t n)
	Allocates a block of memory that can hold `n` elements of type `T` with the specified alignment.

template<typename T , std::size_t Alignment = alignof(T), class Deleter = AlignedDeleter>
std::unique_ptr< T, Deleter >	makeAlignedUnique (std::size_t n, Deleter deleter=Deleter())
	Creates a std::unique_ptr for aligned memory.

template<typename T , std::size_t Alignment = alignof(T), class Deleter = AlignedDeleter>
std::shared_ptr< T >	makeAlignedShared (std::size_t n, Deleter deleter=Deleter())
	Creates a std::shared_ptr for aligned memory.

template<class T , class U , std::size_t Alignment>
bool	operator== (const AlignedAllocator< T, Alignment > &, const AlignedAllocator< U, Alignment > &)
	Checks if storage allocated from `lhs` can be deallocated from `rhs`, and vice versa.

template<class T , class U , std::size_t Alignment>
bool	operator!= (const AlignedAllocator< T, Alignment > &, const AlignedAllocator< U, Alignment > &)
	Checks if storage allocated from `lhs` cannot be deallocated from `rhs`, and vice versa.

std::map< std::string, LogLevel >	logLevelMap ()

void	setLogLevel (LogLevel level)

void	setLogLevel (const std::string &levelStr)

LogLevel	getLogLevel ()

template<typename StringType >
StringType	trim (const StringType &text, const char *whiteChars=" \t")
	Returns a copy of the string from which all the characters in whiteChars at the beginning or at the end of the string have been removed.

template std::string	trim (const std::string &text, const char *whiteChars)

template std::string_view	trim (const std::string_view &text, const char *whiteChars)

std::string	trim (const char text, const char whiteChars=" \t")
	Returns a copy of the string from which all the characters in whiteChars at the beginning or at the end of the string have been removed.

std::vector< std::string >	tokenize (const std::string &inputString, const std::string &delimiters=" \t\r\n", bool trim=true)
	Tokenize a string using the specified delimiters.

std::vector< std::string_view >	tokenize (std::string_view inputString, std::string_view delimiters=" \t\r\n", bool trim=true)
	Tokenize a string_view using the specified delimiters.

template<size_t Alignment>
size_t	computeOffset (const Eigen::Ref< Eigen::MatrixXf > &mat)
	Computes the offset required for the matrix data to meet the alignment requirement.

template<size_t Alignment>
void	checkAlignment (const Eigen::Ref< Eigen::MatrixXf > &mat, size_t offset=0)
	Checks if the data of the matrix is aligned correctly.

template<typename Derived , typename S >
FloatP	dot (const Eigen::MatrixBase< Derived > &v1, const Vector3P< S > &v2)
	Calculates dot product of Eigen::Vector3f and 3-vector of packets.

template<typename Derived , typename S >
FloatP	dot (const Vector3P< S > &v1, const Eigen::MatrixBase< Derived > &v2)
	Calculates dot product of Vector3P and Eigen::Vector3f.

template<typename S , typename Derived >
Vector3P< S >	operator+ (const Eigen::MatrixBase< Derived > &v1, const Vector3P< S > &v2)
	Calculates summation of Eigen::Vector3f and Vector3P.

template<typename S , typename Derived >
Vector3P< S >	operator+ (const Vector3P< S > &v1, const Eigen::MatrixBase< Derived > &v2)
	Calculates summation of Vector3P and Eigen::Vector3f.

template<typename S , typename Derived >
Vector3P< S >	operator- (const Eigen::MatrixBase< Derived > &v1, const Vector3P< S > &v2)
	Calculates subtraction of Eigen::Vector3f and Vector3P.

template<typename S , typename Derived >
Vector3P< S >	operator- (const Vector3P< S > &v1, const Eigen::MatrixBase< Derived > &v2)
	Calculates subtraction of Vector3P and Eigen::Vector3f.

template<typename S >
Vector3P< S >	operator* (const Eigen::Quaternion< S > &q, const Vector3P< S > &vec)
	Calculates multiplication of quaternion and each 3x1 vector in packet.

template<typename S , typename Derived >
Vector3P< S >	operator* (const Eigen::MatrixBase< Derived > &xf, const Vector3P< S > &vec)
	Calculates multiplication of 3x3 matrix and each 3x1 vector in packet.

template<typename S >
Vector3P< S >	operator* (const Eigen::Transform< S, 3, Eigen::Affine > &xf, const Vector3P< S > &vec)
	Calculates affine transformation on each 3x1 vector in packet.

template<typename S >
Vector3P< S >	operator* (const TransformT< S > &xf, const Vector3P< S > &vec)
	Calculates transformation on each 3x1 vector in packet using momentum::Transform.

template<typename S , typename Derived >
Vector3P< S >	cross (const Eigen::MatrixBase< Derived > &v1, const Vector3P< S > &v2)
	Calculates cross product of Eigen::Vector3f and Vector3P.

template<typename S , typename Derived >
Vector3P< S >	cross (const Vector3P< S > &v1, const Eigen::MatrixBase< Derived > &v2)
	Calculates cross product of Vector3P and Eigen::Vector3f.

template<typename T = float>
constexpr T	nan () noexcept

template<typename T >
constexpr T	Eps (T FloatEps=T(1e-7), T DoubleEps=T(1e-16))
	Returns the tolerance value based on the provided type T.

template<typename T = float>
constexpr T	ln2 () noexcept

template<typename T = float>
constexpr T	pi () noexcept

template<typename T = float>
constexpr T	twopi () noexcept

template<typename T = float>
constexpr T	toRad (T x=T(1)) noexcept
	Converts the given angle x (in degrees) to radians.

template<typename T = float>
constexpr T	toDeg (T x=T(1)) noexcept
	Converts the given angle x (in radians) to degrees.

template<typename T = float>
constexpr T	toM (T x=T(1)) noexcept
	Converts the given length x (in centimeters) to meters.

template<typename T = float>
constexpr T	toCm (T x=T(1)) noexcept
	Converts the given length x (in meters) to centimeters.

template<typename T >
bool	intersectFace (const MeshT< T > &mesh, const std::vector< Vector3< T > > &faceNormals, int32_t face0, int32_t face1)
	test whether two given faces of a mesh intersect with each other

template<typename T >
std::vector< std::pair< int32_t, int32_t > >	intersectMeshBruteForce (const MeshT< T > &mesh)
	test if the mesh self intersects anywhere and return all intersecting face pairs using brute force

template<typename T >
std::vector< std::pair< int32_t, int32_t > >	intersectMesh (const MeshT< T > &mesh)
	test if the mesh self intersects anywhere and return all intersecting face pairs using a bvh tree

template bool	intersectFace< float > (const MeshT< float > &mesh, const std::vector< Vector3< float > > &faceNormals, const int32_t face0, const int32_t face1)

template bool	intersectFace< double > (const MeshT< double > &mesh, const std::vector< Vector3< double > > &faceNormals, const int32_t face0, const int32_t face1)

template std::vector< std::pair< int32_t, int32_t > >	intersectMeshBruteForce< float > (const MeshT< float > &mesh)

template std::vector< std::pair< int32_t, int32_t > >	intersectMeshBruteForce< double > (const MeshT< double > &mesh)

template std::vector< std::pair< int32_t, int32_t > >	intersectMesh< float > (const MeshT< float > &mesh)

template std::vector< std::pair< int32_t, int32_t > >	intersectMesh< double > (const MeshT< double > &mesh)

template<typename T , typename T2 , int N>
std::vector< Eigen::Vector< T2, N > >	castVectors (const std::vector< Eigen::Vector< T, N > > &vec_in)

template<typename T , typename T2 >
std::vector< Eigen::MatrixX< T2 > >	castMatrices (std::span< const Eigen::MatrixX< T > > m_in)

void	validateColumnIndices (std::span< const Eigen::Index > colIndices, Eigen::Index maxEntry)

template<typename T >
T	uniform (const T &min, const T &max)
	Generates a random type T from the uniform distribution, using the global random number generator Random.

template<typename FixedSizeT >
FixedSizeT	uniform (typename FixedSizeT::Scalar min, typename FixedSizeT::Scalar max)
	Generates a random fixed size vector/matrix from the uniform distribution, using the global random number generator Random.

template<typename DynamicVector >
DynamicVector	uniform (Eigen::Index size, typename DynamicVector::Scalar min, typename DynamicVector::Scalar max)
	Generates a random dynamic size vector from the uniform distribution, using the global random number generator Random.

template<typename DynamicMatrix >
DynamicMatrix	uniform (Eigen::Index rows, Eigen::Index cols, typename DynamicMatrix::Scalar min, typename DynamicMatrix::Scalar max)
	Generates a random type dynamic size matrix from the uniform distribution, using the global random number generator Random.

template<typename T >
Quaternion< T >	uniformQuaternion ()
	Generates a random quaternion from a uniform distribution on SO(3)

template<typename T >
Matrix3< T >	uniformRotationMatrix ()
	Generates a random rotation matrix from a uniform distribution on SO(3)

template<typename T >
Isometry3< T >	uniformIsometry3 (const Vector3< T > &min=Vector3< T >::Zero(), const Vector3< T > &max=Vector3< T >::Ones())
	Generates a random isometry (rigid transformation) from a uniform distribution on SE(3) based on input minimum and maximum 3D vectors for the translation part.

template<typename T >
Affine3< T >	uniformAffine3 (T scaleMin=0.1, T scaleMax=10.0, const Vector3< T > &min=Vector3< T >::Zero(), const Vector3< T > &max=Vector3< T >::Ones())
	Generates a random affine transformation from a uniform distribution on the space of all affine transformations.

template<typename T >
T	normal (const T &mean, const T &sigma)
	Generates a random type T from the Gaussian distribution, using the global random number generator Random.

template<typename FixedSizeT >
FixedSizeT	normal (typename FixedSizeT::Scalar mean, typename FixedSizeT::Scalar sigma)
	Generates a random fixed size vector/matrix from the Gaussian distribution, using the global random number generator Random.

template<typename DynamicVector >
DynamicVector	normal (Eigen::Index size, typename DynamicVector::Scalar mean, typename DynamicVector::Scalar sigma)
	Generates a random dynamic size vector from the Gaussian distribution, using the global random number generator Random.

template<typename DynamicMatrix >
DynamicMatrix	normal (Eigen::Index rows, Eigen::Index cols, typename DynamicMatrix::Scalar mean, typename DynamicMatrix::Scalar sigma)
	Generates a random dynamic size matrix from the Gaussian distribution, using the global random number generator Random.

template<typename T >
TransformT< T >	blendTransforms (std::span< const TransformT< T > > transforms, std::span< const T > weights)

template<typename T >
TransformT< T >	slerp (const TransformT< T > &t1, const TransformT< T > &t2, T weight)
	Spherical linear interpolation between two transforms.

template TransformT< float >	blendTransforms (std::span< const TransformT< float > > transforms, std::span< const float > weights)

template TransformT< double >	blendTransforms (std::span< const TransformT< double > > transforms, std::span< const double > weights)

template TransformT< float >	slerp (const TransformT< float > &, const TransformT< float > &, float)

template TransformT< double >	slerp (const TransformT< double > &, const TransformT< double > &, double)

template<typename OtherScalar , template< typename... > class ContainerType, typename ObjectType >
decltype(auto)	cast (const ContainerType< ObjectType > &originalContainer)
	Casts the scalar type of objects in a container that support the `cast<>()` method.

template MatrixX< float >	pseudoInverse (const MatrixX< float > &mat)

template MatrixX< double >	pseudoInverse (const MatrixX< double > &mat)

template MatrixX< float >	pseudoInverse (const SparseMatrix< float > &mat)

template MatrixX< double >	pseudoInverse (const SparseMatrix< double > &mat)

template Quaternion< float >	quaternionExpMap (const Vector3< float > &v)

template Quaternion< double >	quaternionExpMap (const Vector3< double > &v)

template Vector3< float >	quaternionLogMap (const Quaternion< float > &q)

template Vector3< double >	quaternionLogMap (const Quaternion< double > &q)

template Eigen::Matrix< float, 3, 4 >	quaternionLogMapDerivative (const Quaternion< float > &q)

template Eigen::Matrix< double, 3, 4 >	quaternionLogMapDerivative (const Quaternion< double > &q)

template Vector3< float >	rotationMatrixToEuler (const Matrix3< float > &m, int axis0, int axis1, int axis2, EulerConvention convention)

template Vector3< double >	rotationMatrixToEuler (const Matrix3< double > &m, int axis0, int axis1, int axis2, EulerConvention convention)

template Vector3< float >	rotationMatrixToEulerXYZ (const Matrix3< float > &m, EulerConvention convention)

template Vector3< double >	rotationMatrixToEulerXYZ (const Matrix3< double > &m, EulerConvention convention)

template Vector3< float >	rotationMatrixToEulerZYX (const Matrix3< float > &m, EulerConvention convention)

template Vector3< double >	rotationMatrixToEulerZYX (const Matrix3< double > &m, EulerConvention convention)

template Quaternion< float >	eulerToQuaternion (const Vector3< float > &angles, int axis0, int axis1, int axis2, EulerConvention convention)

template Quaternion< double >	eulerToQuaternion (const Vector3< double > &angles, int axis0, int axis1, int axis2, EulerConvention convention)

template Matrix3< float >	eulerToRotationMatrix (const Vector3< float > &angles, int axis0, int axis1, int axis2, EulerConvention convention)

template Matrix3< double >	eulerToRotationMatrix (const Vector3< double > &angles, int axis0, int axis1, int axis2, EulerConvention convention)

template Matrix3< float >	eulerXYZToRotationMatrix (const Vector3< float > &angles, EulerConvention convention)

template Matrix3< double >	eulerXYZToRotationMatrix (const Vector3< double > &angles, EulerConvention convention)

template Matrix3< float >	eulerZYXToRotationMatrix (const Vector3< float > &angles, EulerConvention convention)

template Matrix3< double >	eulerZYXToRotationMatrix (const Vector3< double > &angles, EulerConvention convention)

template Vector3f	quaternionToEuler (const Quaternionf &q)

template Vector3d	quaternionToEuler (const Quaterniond &q)

template std::tuple< bool, float, Eigen::Vector2< float > >	closestPointsOnSegments< float > (const Eigen::Vector3< float > &o1, const Eigen::Vector3< float > &d1, const Eigen::Vector3< float > &o2, const Eigen::Vector3< float > &d2, const float maxDist)

template std::tuple< bool, double, Eigen::Vector2< double > >	closestPointsOnSegments< double > (const Eigen::Vector3< double > &o1, const Eigen::Vector3< double > &d1, const Eigen::Vector3< double > &o2, const Eigen::Vector3< double > &d2, const double maxDist)

template float	rotationMatrixToOneAxisEuler (const Matrix3< float > &m, int axis0)

template double	rotationMatrixToOneAxisEuler (const Matrix3< double > &m, int axis0)

template Vector2< float >	rotationMatrixToTwoAxisEuler (const Matrix3< float > &m, int axis0, int axis1)

template Vector2< double >	rotationMatrixToTwoAxisEuler (const Matrix3< double > &m, int axis0, int axis1)

bool	IsNanNoOpt (float f)
	NaN check function that isn't optimized away by fastmath.

template<typename T >
BlendWeightsT< T >	extractBlendWeights (const ParameterTransform &paramTransform, const ModelParametersT< T > &modelParams)
	Extracts blend shape weights from model parameters.

template<typename T >
BlendWeightsT< T >	extractFaceExpressionBlendWeights (const ParameterTransform &paramTransform, const ModelParametersT< T > &modelParams)
	Extracts facial expression blend shape weights from model parameters.

template<typename T >
void	skinWithBlendShapes (const Character &character, const SkeletonStateT< T > &state, const ModelParametersT< T > &modelParams, MeshT< T > &outputMesh)
	Applies blend shape deformations and skeletal transformations to a mesh.

template<typename T >
void	skinWithBlendShapes (const Character &character, const SkeletonStateT< T > &state, const BlendWeightsT< T > &blendWeights, MeshT< T > &outputMesh)
	Applies blend shape deformations and skeletal transformations to a mesh.

template void	skinWithBlendShapes (const Character &character, const SkeletonStateT< float > &state, const BlendWeightsT< float > &modelParams, MeshT< float > &outputMesh)

template void	skinWithBlendShapes (const Character &character, const SkeletonStateT< double > &state, const BlendWeightsT< double > &modelParams, MeshT< double > &outputMesh)

template void	skinWithBlendShapes (const Character &character, const SkeletonStateT< float > &state, const ModelParametersT< float > &modelParams, MeshT< float > &outputMesh)

template void	skinWithBlendShapes (const Character &character, const SkeletonStateT< double > &state, const ModelParametersT< double > &modelParams, MeshT< double > &outputMesh)

template BlendWeightsT< float >	extractBlendWeights< float > (const ParameterTransform &paramTransform, const ModelParametersT< float > &modelParams)

template BlendWeightsT< double >	extractBlendWeights< double > (const ParameterTransform &paramTransform, const ModelParametersT< double > &modelParams)

template BlendWeightsT< float >	extractFaceExpressionBlendWeights< float > (const ParameterTransform &paramTransform, const ModelParametersT< float > &modelParams)

template BlendWeightsT< double >	extractFaceExpressionBlendWeights< double > (const ParameterTransform &paramTransform, const ModelParametersT< double > &modelParams)

Character	scaleCharacter (const Character &character, float scale)
	Scales the character (mesh and skeleton) by the desired amount.

Character	transformCharacter (const Character &character, const Affine3f &xform)
	Transforms the character (mesh and skeleton) by the desired transformation matrix.

Character	replaceSkeletonHierarchy (const Character &srcCharacter, const Character &tgtCharacter, const std::string &srcRootJoint, const std::string &tgtRootJoint)
	Replaces the part of target_character's skeleton rooted at target_root with the part of source_character's skeleton rooted at source_root.

Character	removeJoints (const Character &character, std::span< const size_t > jointsToRemove)
	Removes the specified joints and any joints parented beneath them from the character.

MatrixXf	mapMotionToCharacter (const MotionParameters &inputMotion, const Character &targetCharacter)
	Maps the input ModelParameter motion to a target character by matching model parameter names.

VectorXf	mapIdentityToCharacter (const IdentityParameters &inputIdentity, const Character &targetCharacter)
	Maps the input JointParameter vector to a target character by matching joint names.

template<typename T >
CharacterT< T >	reduceMeshByVertices (const CharacterT< T > &character, const std::vector< bool > &activeVertices)
	Reduces the mesh to only include the specified vertices and associated faces.

template<typename T >
CharacterT< T >	reduceMeshByFaces (const CharacterT< T > &character, const std::vector< bool > &activeFaces)
	Reduces the mesh to only include the specified faces and associated vertices.

template<typename T >
std::vector< bool >	verticesToFaces (const MeshT< T > &mesh, const std::vector< bool > &activeVertices)
	Converts vertex selection to face selection.

template<typename T >
std::vector< bool >	facesToVertices (const MeshT< T > &mesh, const std::vector< bool > &activeFaces)
	Converts face selection to vertex selection.

template CharacterT< float >	reduceMeshByVertices< float > (const CharacterT< float > &character, const std::vector< bool > &activeVertices)

template CharacterT< double >	reduceMeshByVertices< double > (const CharacterT< double > &character, const std::vector< bool > &activeVertices)

template CharacterT< float >	reduceMeshByFaces< float > (const CharacterT< float > &character, const std::vector< bool > &activeFaces)

template CharacterT< double >	reduceMeshByFaces< double > (const CharacterT< double > &character, const std::vector< bool > &activeFaces)

template std::vector< bool >	verticesToFaces< float > (const MeshT< float > &mesh, const std::vector< bool > &activeVertices)

template std::vector< bool >	verticesToFaces< double > (const MeshT< double > &mesh, const std::vector< bool > &activeVertices)

template std::vector< bool >	facesToVertices< float > (const MeshT< float > &mesh, const std::vector< bool > &activeFaces)

template std::vector< bool >	facesToVertices< double > (const MeshT< double > &mesh, const std::vector< bool > &activeFaces)

template<typename T >
bool	overlaps (const Vector3< T > &originA, const Vector3< T > &directionA, const Vector2< T > &radiiA, T deltaA, const Vector3< T > &originB, const Vector3< T > &directionB, const Vector2< T > &radiiB, T deltaB, T &outDistance, Vector2< T > &outClosestPoints, T &outOverlap)
	Determines if two tapered capsules overlap.

template<typename T >
void	updateAabb (axel::BoundingBox< T > &aabb, const Vector3< T > &originA, const Vector3< T > &direction, const Vector2< T > &radii)
	Updates an axis-aligned bounding box to encompass a tapered capsule.

template<typename T >
Eigen::SparseMatrix< T >	toColumnMajor (const SparseRowMatrix< T > &mat)

template<typename T >
std::vector< Vector3< T > >	applySSD (const TransformationListT< T > &inverseBindPose, const SkinWeights &skin, typename DeduceSpanType< const Vector3< T > >::type points, const SkeletonStateT< T > &state)
	Applies forward SSD (linear blend skinning) to points, returning new points.

template<typename T >
void	applySSD (const TransformationListT< T > &inverseBindPose, const SkinWeights &skin, const MeshT< T > &mesh, const SkeletonStateT< T > &state, MeshT< T > &outputMesh)
	Applies forward SSD to a mesh using skeleton state, modifying output mesh.

template<typename T >
void	applySSD (const TransformationListT< T > &inverseBindPose, const SkinWeights &skin, const MeshT< T > &mesh, const JointStateListT< T > &state, MeshT< T > &outputMesh)
	Applies forward SSD to a mesh using raw joint state list, modifying output mesh.

Affine3f	getInverseSSDTransformation (const TransformationList &inverseBindPose, const SkinWeights &skin, const SkeletonState &state, size_t index)
	Computes the inverse SSD transformation for a specific vertex.

void	applyInverseSSD (const TransformationList &inverseBindPose, const SkinWeights &skin, std::span< const Vector3f > points, const SkeletonState &state, Mesh &mesh)
	Applies inverse SSD to points, storing results in a mesh.

std::vector< Vector3f >	applyInverseSSD (const TransformationList &inverseBindPose, const SkinWeights &skin, std::span< const Vector3f > points, const SkeletonState &state)
	Applies inverse SSD to points, returning new points in bind pose space.

template std::vector< Vector3f >	applySSD< float > (const TransformationListT< float > &inverseBindPose, const SkinWeights &skin, typename DeduceSpanType< const Vector3< float > >::type points, const SkeletonStateT< float > &state)

template std::vector< Vector3d >	applySSD< double > (const TransformationListT< double > &inverseBindPose, const SkinWeights &skin, typename DeduceSpanType< const Vector3< double > >::type points, const SkeletonStateT< double > &state)

template void	applySSD< float > (const TransformationList &inverseBindPose, const SkinWeights &skin, const MeshT< float > &mesh, const SkeletonStateT< float > &jointState, MeshT< float > &outputMesh)

template void	applySSD< double > (const TransformationListT< double > &inverseBindPose, const SkinWeights &skin, const MeshT< double > &mesh, const SkeletonStateT< double > &jointState, MeshT< double > &outputMesh)

template void	applySSD< float > (const TransformationListT< float > &inverseBindPose, const SkinWeights &skin, const MeshT< float > &mesh, const JointStateListT< float > &jointState, MeshT< float > &outputMesh)

template void	applySSD< double > (const TransformationListT< double > &inverseBindPose, const SkinWeights &skin, const MeshT< double > &mesh, const JointStateListT< double > &jointState, MeshT< double > &outputMesh)

std::string_view	toString (const LimitType type)

JointParameters	applyPassiveJointParameterLimits (const ParameterLimits &limits, const JointParameters &jointParams)
	Only processes MinMaxJointPassive limits, clamping parameters to their ranges.

ParameterLimits	getPoseConstraintParameterLimits (const std::string &name, const ParameterTransform &pt, float weight=1.0f)
	Creates MinMax limits from a pose constraint.

bool	isInRange (const LimitLinear &limit, float value)
	If rangeMin and rangeMax are both 0, the limit applies to all values.

bool	isInRange (const LimitLinearJoint &limit, float value)
	If rangeMin and rangeMax are both 0, the limit applies to all values.

template<typename T >
ParameterTransformT< T >	mapParameterTransformJoints (const ParameterTransformT< T > &parameterTransform, size_t numTargetJoints, const std::vector< size_t > &jointMapping)
	Construct a new parameter transform where the joints have been mapped to a new skeleton.

template<typename T >
std::tuple< ParameterTransformT< T >, ParameterLimits >	subsetParameterTransform (const ParameterTransformT< T > &paramTransform, const ParameterLimits &paramLimitsOld, const ParameterSet &paramSet)
	Return a parameter mapping that only includes the listed parameters.

std::tuple< ParameterTransform, ParameterLimits >	addBlendShapeParameters (ParameterTransform paramTransform, ParameterLimits paramLimits, Eigen::Index nBlendShapes)

std::tuple< ParameterTransform, ParameterLimits >	addFaceExpressionParameters (ParameterTransform paramTransform, ParameterLimits paramLimits, Eigen::Index nFaceExpressionBlendShapes)

std::tuple< ParameterTransform, ParameterLimits >	addSkinnedLocatorParameters (ParameterTransform paramTransform, ParameterLimits paramLimits, const std::vector< bool > &activeLocators, const std::vector< std::string > &locatorNames={})
	Add a set of parameters that control the rest-space positions of the skinned locators.

template std::tuple< ParameterTransformT< float >, ParameterLimits >	subsetParameterTransform (const ParameterTransformT< float > &paramTransform, const ParameterLimits &parameterLimits, const ParameterSet &paramSet)

template std::tuple< ParameterTransformT< double >, ParameterLimits >	subsetParameterTransform (const ParameterTransformT< double > &paramTransform, const ParameterLimits &parameterLimits, const ParameterSet &paramSet)

template ParameterTransformT< float >	mapParameterTransformJoints (const ParameterTransformT< float > &paramTransform, size_t numTargetJoints, const std::vector< size_t > &jointMapping)

template ParameterTransformT< double >	mapParameterTransformJoints (const ParameterTransformT< double > &paramTransform, size_t numTargetJoints, const std::vector< size_t > &jointMapping)

template<typename T >
TransformT< T >	transformAtoB (size_t jointA, size_t jointB, const Skeleton &referenceSkeleton, const SkeletonStateT< T > &skelState)
	Computes the relative transform between two joints in a skeleton.

template<typename T >
JointParametersT< T >	skeletonStateToJointParameters (const SkeletonStateT< T > &state, const Skeleton &skeleton)
	Invert the skeleton state (global transforms in world space) back to joint parameters (Euler angles in local space).

template<typename T >
JointParametersT< T >	skeletonStateToJointParameters (const TransformListT< T > &state, const Skeleton &skeleton)

template<typename T >
JointParametersT< T >	skeletonStateToJointParametersRespectingActiveParameters (const SkeletonStateT< T > &state, const Skeleton &skeleton, const VectorX< bool > &activeJointParams)
	Converts skeleton state back to joint parameters, respecting active joint parameter constraints.

template<typename T >
JointParametersT< T >	skeletonStateToJointParametersRespectingActiveParameters (const TransformListT< T > &state, const Skeleton &skeleton, const VectorX< bool > &activeJointParams)
	Converts transform list back to joint parameters, respecting active joint parameter constraints.

template TransformT< float >	transformAtoB (size_t jointA, size_t jointB, const Skeleton &referenceSkeleton, const SkeletonStateT< float > &skelState)

template TransformT< double >	transformAtoB (size_t jointA, size_t jointB, const Skeleton &referenceSkeleton, const SkeletonStateT< double > &skelState)

template JointParametersT< float >	skeletonStateToJointParameters (const SkeletonStateT< float > &state, const Skeleton &skeleton)

template JointParametersT< double >	skeletonStateToJointParameters (const SkeletonStateT< double > &state, const Skeleton &skeleton)

template JointParametersT< float >	skeletonStateToJointParameters (const TransformListT< float > &state, const Skeleton &skeleton)

template JointParametersT< double >	skeletonStateToJointParameters (const TransformListT< double > &state, const Skeleton &skeleton)

template JointParametersT< float >	skeletonStateToJointParametersRespectingActiveParameters (const SkeletonStateT< float > &state, const Skeleton &skeleton, const VectorX< bool > &activeJointParams)

template JointParametersT< double >	skeletonStateToJointParametersRespectingActiveParameters (const SkeletonStateT< double > &state, const Skeleton &skeleton, const VectorX< bool > &activeJointParams)

template JointParametersT< float >	skeletonStateToJointParametersRespectingActiveParameters (const TransformListT< float > &state, const Skeleton &skeleton, const VectorX< bool > &activeJointParams)

template JointParametersT< double >	skeletonStateToJointParametersRespectingActiveParameters (const TransformListT< double > &state, const Skeleton &skeleton, const VectorX< bool > &activeJointParams)

ModelParameters	extrapolateModelParameters (const ModelParameters &previous, const ModelParameters &current, float factor=kDefaultExtrapolateFactor, float maxDelta=kDefaultExtrapolateMaxDelta)
	Extrapolates model parameters by first clamping the difference between current and previous parameters to the range [-maxDelta, maxDelta], and then scaling this clamped difference by `factor`.

ModelParameters	extrapolateModelParameters (const ModelParameters &previous, const ModelParameters &current, const ParameterSet &activeParams, float factor=kDefaultExtrapolateFactor, float maxDelta=kDefaultExtrapolateMaxDelta)
	Extrapolates model parameters considering active parameters.

template<typename T >
void	gradient_jointParams_to_modelParams (const T &grad_jointParams, const Eigen::Index iJointParam, const ParameterTransform &parameterTransform, Eigen::Ref< Eigen::VectorX< T > > gradient)

template<typename T >
void	jacobian_jointParams_to_modelParams (const Eigen::Ref< const Eigen::VectorX< T > > &jacobian_jointParams, const Eigen::Index iJointParam, const ParameterTransform &parameterTransform, Eigen::Ref< Eigen::MatrixX< T > > jacobian)

template<typename T >
void	jacobian_jointParams_to_modelParams (const T &jacobian_jointParams, const Eigen::Index iJointParam, const ParameterTransform &parameterTransform, Eigen::Ref< Eigen::MatrixX< T > > jacobian)

template<typename T >
std::vector< PlaneDataT< T > >	createFloorConstraints (const std::string &prefix, const LocatorList &locators, const Vector3< T > &floorNormal, const T &floorOffset, float weight)
	Create non-penetration half-plane constraints from locators with the input prefix.

template std::vector< PlaneDataT< float > >	createFloorConstraints< float > (const std::string &prefix, const LocatorList &locators, const Vector3f &floorNormal, const float &floorOffset, const float weight)

template std::vector< PlaneDataT< double > >	createFloorConstraints< double > (const std::string &prefix, const LocatorList &locators, const Vector3d &floorNormal, const double &floorOffset, const float weight)

template<typename T >
Eigen::Vector3< T >	computeTargetBaryPosition (const MeshT< T > &mesh, const PointTriangleVertexConstraintT< T > &c)

template<typename T >
Eigen::Vector3< T >	computeTargetTriangleNormal (const MeshT< T > &mesh, const PointTriangleVertexConstraintT< T > &c)

template<typename T >
Eigen::Vector3< T >	computeTargetPosition (const MeshT< T > &mesh, const PointTriangleVertexConstraintT< T > &c)

template<typename T >
void	gradient_jointParams_to_modelParams (const T grad_jointParams, const Eigen::Index iJointParam, const ParameterTransform &parameterTransform, Eigen::Ref< Eigen::VectorX< T > > gradient)

template<typename T >
void	jacobian_jointParams_to_modelParams (const Eigen::Ref< const Eigen::VectorX< T > > jacobian_jointParams, const Eigen::Index iJointParam, const ParameterTransform &parameterTransform, Eigen::Ref< Eigen::MatrixX< T > > jacobian)

template<typename T >
void	jacobian_jointParams_to_modelParams (const T jacobian_jointParams, const Eigen::Index iJointParam, const ParameterTransform &parameterTransform, Eigen::Ref< Eigen::MatrixX< T > > jacobian)

template<typename T >
Eigen::Vector3< T >	calculateDWorldPos (const momentum::Character &character, const SkeletonStateT< T > &state, const int vertexIndex, const Eigen::Vector3< T > &d_restPos)

template<typename T >
std::array< Eigen::Matrix3< T >, 3 >	compute_d_targetNormal_d_vertexPos (const PointTriangleVertexConstraintT< T > &cons, const MeshT< T > &mesh)

template<typename T >
std::array< Eigen::Matrix3< T >, 3 >	compute_d_targetPos_d_vertexPos (const PointTriangleVertexConstraintT< T > &cons, const MeshT< T > &mesh)

template<typename T >
Eigen::VectorX< T >	mapParameters (const ModelParametersT< T > &in, const std::vector< size_t > &mp)

__vectorcall DRJIT_INLINE void	jacobian_jointParams_to_modelParams (const FloatP &jacobian_jointParams, const Eigen::Index iJointParam, const ParameterTransform &parameterTransform_, Eigen::Ref< Eigen::MatrixX< float > > jacobian)

template<typename T >
std::pair< size_t, std::vector< size_t > >	getDimensions (const std::vector< std::shared_ptr< SkeletonErrorFunctionT< T > > > &error_func)

template<typename T >
Eigen::Vector3< T >	computeTargetBaryPosition (const MeshT< T > &mesh, const SkinnedLocatorTriangleConstraintT< T > &c)

template<typename T >
Eigen::Vector3< T >	computeTargetTriangleNormal (const MeshT< T > &mesh, const SkinnedLocatorTriangleConstraintT< T > &c)

template<typename T >
Eigen::Vector3< T >	computeTargetPosition (const MeshT< T > &mesh, const SkinnedLocatorTriangleConstraintT< T > &c)

template<typename T >
std::array< Eigen::Matrix3< T >, 3 >	compute_d_targetNormal_d_vertexPos (const SkinnedLocatorTriangleConstraintT< T > &cons, const MeshT< T > &mesh)

template<typename T >
std::array< Eigen::Matrix3< T >, 3 >	compute_d_targetPos_d_vertexPos (const SkinnedLocatorTriangleConstraintT< T > &cons, const MeshT< T > &mesh)

template<typename T >
std::vector< ModelParametersT< T > >	transformPose (const Character &character, const std::vector< ModelParametersT< T > > &modelParameters, const TransformT< T > &transforms)

template<typename T >
std::vector< ModelParametersT< T > >	transformPose (const Character &character, const std::vector< ModelParametersT< T > > &modelParameters, const std::vector< TransformT< T > > &transforms, bool ensureContinuousOutput=true)
	Function which computes a new set of model parameters such that the character pose is a rigidly transformed version of the original pose.

template std::vector< ModelParametersT< float > >	transformPose (const Character &characterFull, const std::vector< ModelParametersT< float > > &modelParametersFull, const std::vector< TransformT< float > > &transforms, bool ensureContinuousOutput)

template std::vector< ModelParametersT< double > >	transformPose (const Character &characterFull, const std::vector< ModelParametersT< double > > &modelParametersFull, const std::vector< TransformT< double > > &transforms, bool ensureContinuousOutput)

template std::vector< ModelParametersT< float > >	transformPose (const Character &character, const std::vector< ModelParametersT< float > > &modelParameters, const TransformT< float > &transform)

template std::vector< ModelParametersT< double > >	transformPose (const Character &character, const std::vector< ModelParametersT< double > > &modelParameters, const TransformT< double > &transform)

std::string_view	toString (VertexConstraintType type)

template<typename T , typename T2 >
Eigen::Vector3< T >	getRotationDerivative (const JointStateT< T2 > &js, const size_t index, const Eigen::Vector3< T > &ref)

template<typename T , typename T2 >
Eigen::Vector3< T >	getScaleDerivative (const JointStateT< T2 > &js, const Eigen::Vector3< T > &ref)

template<typename T , int N>
Eigen::Matrix< ceres::Jet< T, N >, N, 1 >	buildJetVec (const Eigen::Matrix< T, N, 1 > &v)

template<typename T , int Rows, int Cols>
Eigen::Matrix< ceres::Jet< T, Cols *Rows >, Rows, Cols >	buildJetMat (const Eigen::Matrix< T, Rows, Cols > &m)

template<typename T , typename T2 >
T	times_parameterTransform_times_v (const T &value, const size_t jointParamIdx, const ParameterTransform &parameterTransform, Eigen::Ref< const Eigen::VectorX< T2 > > v)

template<typename T >
std::vector< Eigen::Index >	computeSubsetParameterIndices (const ParameterTransformT< T > &parameterTransform, const ParameterSet &activeParams)

template<typename T >
Eigen::VectorX< T >	extractSubsetVec (Eigen::Ref< const Eigen::VectorX< T > > fullVec, const std::vector< Eigen::Index > &subsetIndexToFullParamIndex)

template<typename T >
Eigen::MatrixX< T >	extractSubsetMat (Eigen::Ref< const Eigen::MatrixX< T > > fullMat, const std::vector< Eigen::Index > &subsetIndexToFullParamIndex)

template<typename T >
Eigen::VectorX< T >	subsetVecToFullVec (Eigen::Ref< const Eigen::VectorX< T > > subsetVec, const std::vector< Eigen::Index > &subsetIndexToFullParamIndex, Eigen::Index fullVecSize)

float	sqr (float val)

template<typename T >
Eigen::VectorX< T >	hessianInverseTimes (Eigen::Ref< const Eigen::MatrixX< T > > jacobian, Eigen::Ref< const Eigen::VectorX< T > > v)

template<typename T >
std::vector< ErrorFunctionDerivativesT< T > >	d_modelParams_d_inputs (const Skeleton &skeleton, const ParameterTransformT< T > &parameterTransform, const ParameterSet &activeParams, const ModelParametersT< T > &modelParameters, SkeletonSolverFunctionT< T > &solverFunction, Eigen::Ref< const Eigen::VectorX< T > > dLoss_dModelParams, T *gradientRmse)

template std::vector< ErrorFunctionDerivativesT< float > >	d_modelParams_d_inputs< float > (const Skeleton &skeleton, const ParameterTransformT< float > &parameterTransform, const ParameterSet &activeParams, const ModelParametersT< float > &modelParameters, SkeletonSolverFunctionT< float > &solverFunction, Eigen::Ref< const Eigen::VectorX< float > > dLoss_dModelParams, float *gradientRmse)

template std::vector< ErrorFunctionDerivativesT< double > >	d_modelParams_d_inputs< double > (const Skeleton &skeleton, const ParameterTransformT< double > &parameterTransform, const ParameterSet &activeParams, const ModelParametersT< double > &modelParameters, SkeletonSolverFunctionT< double > &solverFunction, Eigen::Ref< const Eigen::VectorX< double > > dLoss_dModelParams, double *gradientRmse)

	MOMENTUM_FWD_DECLARE_TEMPLATE_CLASS (DistanceErrorFunction)

	MOMENTUM_FWD_DECLARE_TEMPLATE_STRUCT (DistanceConstraintData)

	MOMENTUM_FWD_DECLARE_TEMPLATE_CLASS (FullyDifferentiableProjectionErrorFunction)

Character	loadFullCharacter (const std::string &characterPath, const std::string &parametersPath=std::string(), const std::string &locatorsPath=std::string())
	High level function to load a character of any type, with a local path.

Character	loadFullCharacterFromBuffer (CharacterFormat format, std::span< const std::byte > characterBuffer, std::span< const std::byte > paramBuffer=std::span< const std::byte >(), std::span< const std::byte > locBuffer=std::span< const std::byte >())
	Buffer version of loadFullCharacter function, supports .glb and .fbx file formats.

void	saveCharacter (const filesystem::path &filename, const Character &character, float fps=120.f, const MatrixXf &motion=MatrixXf(), std::span< const std::vector< Marker > > markerSequence={}, const FileSaveOptions &options=FileSaveOptions())
	High level function to save a character with motion and markers to any supported format.

void	saveCharacter (const filesystem::path &filename, const Character &character, float fps, std::span< const SkeletonState > skeletonStates, std::span< const std::vector< Marker > > markerSequence={}, const FileSaveOptions &options=FileSaveOptions())
	High level function to save a character with motion in skeleton states and markers to any supported format.

template<typename T >
std::span< T >	cast_span (std::span< std::byte > bs)
	Casts a span of bytes to a span of a different type.

template<typename T >
std::span< const T >	cast_span (std::span< const std::byte > bs)
	Casts a span of const bytes to a span of a different type.

std::istream &	GetLineCrossPlatform (std::istream &is, std::string &line)
	Reads a line from the input stream, handling line endings for different platforms.

Character	loadFbxCharacter (const filesystem::path &inputPath, KeepLocators keepLocators, bool permissive, LoadBlendShapes loadBlendShapes, bool stripNamespaces)

Character	loadFbxCharacter (std::span< const std::byte > inputSpan, KeepLocators keepLocators, bool permissive, LoadBlendShapes loadBlendShapes, bool stripNamespaces)

std::tuple< Character, std::vector< MatrixXf >, float >	loadFbxCharacterWithMotion (const filesystem::path &inputPath, KeepLocators keepLocators, bool permissive, LoadBlendShapes loadBlendShapes, bool stripNamespaces)

std::tuple< Character, std::vector< MatrixXf >, float >	loadFbxCharacterWithMotion (std::span< const std::byte > inputSpan, KeepLocators keepLocators, bool permissive, LoadBlendShapes loadBlendShapes, bool stripNamespaces)

MarkerSequence	loadFbxMarkerSequence (const filesystem::path &filename, bool stripNamespaces=true)
	Loads a MarkerSequence from an FBX file.

void	saveFbx (const filesystem::path &filename, const Character &character, const MatrixXf &poses=MatrixXf(), const VectorXf &identity=VectorXf(), double framerate=120.0, std::span< const std::vector< Marker > > markerSequence={}, const FileSaveOptions &options=FileSaveOptions())
	Save a character with animation to an FBX file.

void	saveFbxWithJointParams (const filesystem::path &filename, const Character &character, const MatrixXf &jointParams=MatrixXf(), double framerate=120.0, std::span< const std::vector< Marker > > markerSequence={}, const FileSaveOptions &options=FileSaveOptions())
	Save a character with animation using joint parameters directly.

void	saveFbxWithSkeletonStates (const filesystem::path &filename, const Character &character, std::span< const SkeletonState > skeletonStates, double framerate=120.0, std::span< const std::vector< Marker > > markerSequence={}, const FileSaveOptions &options=FileSaveOptions())
	Save a character with animation using skeleton states directly.

void	saveFbxModel (const filesystem::path &filename, const Character &character, const FileSaveOptions &options=FileSaveOptions())
	Save a character model (skeleton and mesh) without animation.

Character	loadOpenFbxCharacter (const std::span< const std::byte > inputData, KeepLocators keepLocators, bool permissive, LoadBlendShapes loadBlendShapes, bool stripNamespaces)

Character	loadOpenFbxCharacter (const filesystem::path &path, KeepLocators keepLocators, bool permissive, LoadBlendShapes loadBlendShapes, bool stripNamespaces)

std::tuple< Character, std::vector< MatrixXf >, float >	loadOpenFbxCharacterWithMotion (std::span< const std::byte > inputData, KeepLocators keepLocators, bool permissive, LoadBlendShapes loadBlendShapes, bool stripNamespaces)

std::tuple< Character, std::vector< MatrixXf >, float >	loadOpenFbxCharacterWithMotion (const filesystem::path &inputPath, KeepLocators keepLocators, bool permissive, LoadBlendShapes loadBlendShapes, bool stripNamespaces)

MarkerSequence	loadOpenFbxMarkerSequence (const filesystem::path &filename, bool stripNamespaces)

std::vector< Eigen::Vector3i >	triangulate (std::span< const uint32_t > indices, std::span< const uint32_t > offsets)

Character	loadGltfCharacter (const fx::gltf::Document &model)

Character	loadGltfCharacter (const filesystem::path &gltfFilename)

Character	loadGltfCharacter (std::span< const std::byte > byteSpan)

std::tuple< MotionParameters, IdentityParameters, float >	loadMotion (const filesystem::path &gltfFilename)

std::tuple< Character, MatrixXf, VectorXf, float >	loadCharacterWithMotion (const filesystem::path &gltfFilename)
	Load a glTF character from a local file path.

std::tuple< Character, MatrixXf, VectorXf, float >	loadCharacterWithMotion (std::span< const std::byte > byteSpan)
	Load a glTF character from a buffer.

std::tuple< Character, std::vector< SkeletonState >, std::vector< float > >	loadCharacterWithSkeletonStates (std::span< const std::byte > byteSpan)
	Load a GLTF Character with motion in the form of skeleton states (transform matrices)

std::tuple< Character, std::vector< SkeletonState >, std::vector< float > >	loadCharacterWithSkeletonStates (const filesystem::path &gltfFilename)

std::tuple< MatrixXf, VectorXf, float >	loadMotionOnCharacter (const filesystem::path &gltfFilename, const Character &character)
	Maps the loaded motion onto the input character by matching joint names and parameter names.

std::tuple< MatrixXf, VectorXf, float >	loadMotionOnCharacter (std::span< const std::byte > byteSpan, const Character &character)
	Buffer version of loadMotionOnCharacter()

fx::gltf::Document	makeCharacterDocument (const Character &character, const float fps, const MotionParameters &motion, const IdentityParameters &offsets, std::span< const std::vector< Marker > > markerSequence, bool embedResource, const FileSaveOptions &options)

MarkerSequence	loadMarkerSequence (const filesystem::path &filename)
	Loads a MarkerSequence from a file.

void	saveGltfCharacter (const filesystem::path &filename, const Character &character, float fps=120.0f, const MotionParameters &motion={}, const IdentityParameters &offsets={}, std::span< const std::vector< Marker > > markerSequence={}, const FileSaveOptions &options=FileSaveOptions())
	Saves character motion to a glb file.

void	saveGltfCharacter (const filesystem::path &filename, const Character &character, float fps, std::span< const SkeletonState > skeletonStates, std::span< const std::vector< Marker > > markerSequence={}, const FileSaveOptions &options=FileSaveOptions())
	Saves character skeleton states to a glb file.

std::vector< std::byte >	saveCharacterToBytes (const Character &character, float fps, const MotionParameters &motion, const IdentityParameters &offsets, std::span< const std::vector< Marker > > markerSequence, const FileSaveOptions &options)

template<typename T >
std::vector< T >	copyAccessorBuffer (const fx::gltf::Document &model, int32_t id)

template<typename T >
std::vector< T >	copyAlignedAccessorBuffer (const fx::gltf::Document &model, int32_t id)

template<typename T >
void	setAccessorType (fx::gltf::Accessor &)

template<typename T >
int32_t	createAccessorBuffer (fx::gltf::Document &model, std::span< T > data, const bool align=false, const bool normalized=false)

template<>
void	setAccessorType< const int32_t > (fx::gltf::Accessor &accessor)

template<>
void	setAccessorType< const float > (fx::gltf::Accessor &accessor)

template<>
void	setAccessorType< const Vector2f > (fx::gltf::Accessor &accessor)

template<>
void	setAccessorType< const Vector3f > (fx::gltf::Accessor &accessor)

template<>
void	setAccessorType< const Vector4f > (fx::gltf::Accessor &accessor)

template<>
void	setAccessorType< const Vector3b > (fx::gltf::Accessor &accessor)

template<>
void	setAccessorType< const Vector3i > (fx::gltf::Accessor &accessor)

template<>
void	setAccessorType< const Vector4s > (fx::gltf::Accessor &accessor)

template<>
void	setAccessorType< const Matrix4f > (fx::gltf::Accessor &accessor)

template<typename T >
int32_t	createSampler (fx::gltf::Document &model, fx::gltf::Animation &anim, std::span< T > data, const std::span< float > &timestamps)

template<typename T >
int32_t	createSampler (fx::gltf::Document &model, fx::gltf::Animation &anim, std::span< T > data, const int32_t timestampAccessor)

Vector3f	toMomentumVec3f (const std::array< float, 3 > &vec) noexcept

Vector3f	fromMomentumVec3f (const Vector3f &vec) noexcept

Quaternionf	toMomentumQuaternionf (const std::array< float, 4 > &gltfQuat) noexcept

std::array< float, 4 >	fromMomentumQuaternionf (const Quaternionf &quat) noexcept

void	toMomentumVec3f (std::vector< Vector3f > &vec)

void	fromMomentumVec3f (std::vector< Vector3f > &vec)

void	fromMomentumVec3f (VectorXf &vec)

void	parameterSetsToJson (const Character &character, nlohmann::json &j)

ParameterSets	parameterSetsFromJson (const Character &character, const nlohmann::json &j)

void	poseConstraintsToJson (const Character &character, nlohmann::json &j)

PoseConstraints	poseConstraintsFromJson (const Character &character, const nlohmann::json &j)

void	parameterTransformToJson (const Character &character, nlohmann::json &j)

ParameterTransform	parameterTransformFromJson (const Character &character, const nlohmann::json &j)

void	parameterLimitsToJson (const Character &character, nlohmann::json &j)

ParameterLimits	parameterLimitsFromJson (const Character &character, const nlohmann::json &j)

template<typename Derived >
void	toJson (const Eigen::MatrixBase< Derived > &mat, nlohmann::json &j)

template<typename T >
T	fromJson (const nlohmann::json &j)

void	mppcaToJson (const Character &character, nlohmann::json &j)

Character	loadCharacterFromLegacyJson (const std::string &jsonPath)
	Loads a Character from a legacy JSON format that was previously used by older Python libraries (and some other tools).

Character	loadCharacterFromLegacyJsonBuffer (std::span< const std::byte > jsonBuffer)
	Loads a Character from a legacy JSON buffer.

Character	loadCharacterFromLegacyJsonString (const std::string &jsonString)
	Loads a Character from a legacy JSON string.

void	saveCharacterToLegacyJson (const Character &character, const std::string &jsonPath)
	Saves a Character to legacy JSON format.

std::string	characterToLegacyJsonString (const Character &character)
	Converts a Character to legacy JSON string.

nlohmann::json	characterToLegacyJson (const Character &character)
	Converts a Character to legacy JSON object.

std::vector< MarkerSequence >	loadC3d (const std::string &filename, UpVector up=UpVector::Y, std::span< const std::string > validMarkerNames={})
	Loads all the subjects from a C3D file into a vector of MarkerSequences.

template<typename T >
Vector3< T >	toMomentumVector3 (const Vector3< T > &vec, UpVector up=UpVector::Z, Unit unit=Unit::MM)
	This function converts a 3D vector in the mocap marker coordinate system to the Momentum coordinate system.

template<typename T >
Vector3< T >	toMomentumVector3 (const Vector3< T > &vec, UpVector up, const std::string &unitStr)
	This function converts a 3D vector in the mocap marker coordinate system to the Momentum coordinate system, using a string to specify the unit.

template Vector3< float >	toMomentumVector3 (const Vector3< float > &vec, UpVector up, Unit unit)

template Vector3< double >	toMomentumVector3 (const Vector3< double > &vec, UpVector up, Unit unit)

template Vector3< float >	toMomentumVector3 (const Vector3< float > &vec, UpVector up, const std::string &unitStr)

template Vector3< double >	toMomentumVector3 (const Vector3< double > &vec, UpVector up, const std::string &unitStr)

std::vector< MarkerSequence >	loadMarkers (const std::string &filename, UpVector up=UpVector::Y, std::span< const std::string > validMarkerNames={})
	Loads all actor sequences from a marker file (c3d, trc, glb) and converts the positions to the target coordinate system.

std::optional< MarkerSequence >	loadMarkersForMainSubject (const std::string &filename, UpVector up=UpVector::Y, std::span< const std::string > validMarkerNames={})
	Loads the main subject's marker data from a marker file (c3d, trc, glb) and converts the positions to the target coordinate system.

int	findMainSubjectIndex (std::span< const MarkerSequence > markerSequences)
	Finds the "main subject" from a vector of MarkerSequences.

MarkerSequence	loadTrc (const std::string &filename, UpVector up=UpVector::Y)
	Loads marker data from a TRC file into a MarkerSequence.

void	saveMmo (const std::string &filename, std::span< const VectorXf > poses, const VectorXf &scale, const Character &character)
	Save motion data using character parameter mapping.

void	saveMmo (const std::string &filename, const MatrixXf &poses, const VectorXf &scale, const Character &character, const MatrixXf &additionalParameters=MatrixXf(), std::span< const std::string > additionalParameterNames=std::vector< std::string >())
	Save motion data with optional additional parameters.

void	saveMmo (const std::string &filename, const MatrixXf &poses, const VectorXf &scale, std::span< const std::string > parameterNames, std::span< const std::string > jointNames)
	Save motion data with explicit parameter and joint names.

std::tuple< MatrixXf, VectorXf >	mapMotionToCharacter (const MatrixXf &poses, const VectorXf &offsets, std::span< const std::string > parameterNames, std::span< const std::string > jointNames, const Character &character)
	Map motion data from one parameter space to character parameter space.

std::tuple< MatrixXf, VectorXf >	loadMmo (const std::string &filename, const Character &character)
	Load motion data and map to character parameter space.

std::tuple< MatrixXf, std::vector< std::string > >	getAuxiliaryDataFromMotion (const MatrixXf &poses, std::span< const std::string > parameterNames)
	Extract auxiliary data from motion parameters.

std::tuple< MatrixXf, VectorXf, std::vector< std::string >, std::vector< std::string > >	loadMmo (const std::string &filename)
	Load motion data from file.

BlendShapeBase	loadBlendShapeBase (const filesystem::path &filename, int expectedShapes=-1, int expectedVertices=-1)
	Loads blend shape vectors from a file without base shape.

BlendShapeBase	loadBlendShapeBase (std::istream &data, int expectedShapes=-1, int expectedVertices=-1)
	Loads blend shape vectors from a stream without base shape.

BlendShape	loadBlendShape (const filesystem::path &filename, int expectedShapes=-1, int expectedVertices=-1)
	Loads a blend shape from a file, including base shape and shape vectors.

BlendShape	loadBlendShape (std::istream &data, int expectedShapes=-1, int expectedVertices=-1)
	Loads a blend shape from a stream, including base shape and shape vectors.

void	saveBlendShape (const filesystem::path &filename, const BlendShape &blendShape)
	Saves a blend shape to a file.

void	saveBlendShape (std::ostream &os, const BlendShape &blendShape)
	Saves a blend shape to a stream.

PoseShape	loadPoseShape (const std::string &filename, const Character &character)
	Loads pose shape data from a binary file.

LocatorList	loadLocators (const filesystem::path &filename, const Skeleton &skeleton, const ParameterTransform &parameterTransform)

LocatorList	loadLocatorsFromBuffer (std::span< const std::byte > rawData, const Skeleton &skeleton, const ParameterTransform &parameterTransform)

void	saveLocators (const filesystem::path &filename, const LocatorList &locators, const Skeleton &skeleton, const LocatorSpace space)

std::shared_ptr< const Mppca >	loadMppca (const std::span< const unsigned char > posePriorDataRaw)

std::shared_ptr< const Mppca >	loadMppca (const std::string &name)

std::shared_ptr< const Mppca >	loadMppca (std::istream &inputStream)

void	saveMppca (const Mppca &mppca, const std::string &name)

ParameterLimits	parseParameterLimits (const io_detail::SectionContent &content, const Skeleton &skeleton, const ParameterTransform &parameterTransform)

ParameterLimits	parseParameterLimits (const std::string &data, const Skeleton &skeleton, const ParameterTransform &parameterTransform, size_t lineOffset)

std::string	writeParameterLimits (const ParameterLimits &parameterLimits, const Skeleton &skeleton, const ParameterTransform &parameterTransform)

std::unordered_map< std::string, std::string >	loadMomentumModel (const filesystem::path &filename)

std::unordered_map< std::string, std::string >	loadMomentumModelFromBuffer (std::span< const std::byte > buffer)

ParameterTransform	parseParameterTransform (const SectionContent &content, const Skeleton &skeleton)

ParameterTransform	parseParameterTransform (const std::string &data, const Skeleton &skeleton, size_t lineOffset)

ParameterSets	parseParameterSets (const SectionContent &content, const ParameterTransform &pt)

ParameterSets	parseParameterSets (const std::string &data, const ParameterTransform &pt, size_t lineOffset)

PoseConstraints	parsePoseConstraints (const SectionContent &content, const ParameterTransform &pt)

PoseConstraints	parsePoseConstraints (const std::string &data, const ParameterTransform &pt, size_t lineOffset)

std::tuple< ParameterTransform, ParameterLimits >	loadModelDefinition (const filesystem::path &filename, const Skeleton &skeleton)

std::tuple< ParameterTransform, ParameterLimits >	loadModelDefinition (std::span< const std::byte > rawData, const Skeleton &skeleton)

std::string	writeParameterTransform (const ParameterTransform &parameterTransform, const Skeleton &skeleton)

std::string	writeParameterSets (const ParameterSets &parameterSets)

std::string	writePoseConstraints (const PoseConstraints &poseConstraints)

std::string	writeModelDefinition (const Skeleton &skeleton, const ParameterTransform &parameterTransform, const ParameterLimits &parameterLimits)
	Write complete model definition file.

ParameterTransform	parseParameterTransform (const io_detail::SectionContent &content, const Skeleton &skeleton)

ParameterSets	parseParameterSets (const io_detail::SectionContent &content, const ParameterTransform &pt)

PoseConstraints	parsePoseConstraints (const io_detail::SectionContent &content, const ParameterTransform &pt)

void	loadParameters (std::unordered_map< std::string, std::string > &param, Character &character)

template<typename T >
CharacterT< T >	loadUrdfCharacter (const filesystem::path &filepath)
	Loads a character from a URDF file.

template CharacterT< float >	loadUrdfCharacter (const filesystem::path &filepath)

template<typename T >
CharacterT< T >	loadUrdfCharacter (std::span< const std::byte > bytes)
	Loads a character from a URDF file using the provided byte data.

template CharacterT< float >	loadUrdfCharacter (std::span< const std::byte > bytes)

Character	loadUsdCharacter (const filesystem::path &inputPath)
	Load a USD character from a local file path.

Character	loadUsdCharacter (std::span< const std::byte > inputSpan)
	Load a USD character from a buffer.

void	saveUsd (const filesystem::path &filename, const Character &character)
	Save a character to a USD file.

void	logMesh (const rerun::RecordingStream &rec, const std::string &streamName, const Mesh &mesh, std::optional< rerun::Color > color)

void	logJoints (const rerun::RecordingStream &rec, const std::string &streamName, const Skeleton &skeleton, const JointStateList &jointStates)

void	logMarkers (const rerun::RecordingStream &rec, const std::string &streamName, std::span< const Marker > markers)

void	logLocators (const rerun::RecordingStream &rec, const std::string &streamName, const LocatorList &locators, const LocatorState &locatorState)

void	logMarkerLocatorCorrespondence (const rerun::RecordingStream &rec, const std::string &streamName, const std::map< std::string, size_t > &locatorLookup, const LocatorState &locatorState, std::span< const Marker > markers, const float kPositionErrorThreshold)

void	logModelParams (const rerun::RecordingStream &rec, const std::string &worldPrefix, const std::string &posePrefix, std::span< const std::string > names, const Eigen::VectorXf &params)

void	logJointParams (const rerun::RecordingStream &rec, const std::string &worldPrefix, const std::string &posePrefix, std::span< const std::string > names, const Eigen::VectorXf &params)

void	logModelParamNames (const rerun::RecordingStream &rec, const std::string &worldPrefix, const std::string &posePrefix, std::span< const std::string > names)

void	logJointParamNames (const rerun::RecordingStream &rec, const std::string &worldPrefix, const std::string &posePrefix, std::span< const std::string > names)

void	logBvh (const rerun::RecordingStream &rec, const std::string &streamName, const CollisionGeometry &collisionGeometry, const SkeletonState &skeletonState)

void	logCollisionGeometry (const rerun::RecordingStream &rec, const std::string &streamName, const CollisionGeometry &collisionGeometry, const SkeletonState &skeletonState)

void	logCharacter (const rerun::RecordingStream &rec, const std::string &charStreamName, const Character &character, const CharacterState &characterState, const rerun::Color &color)

bool	redirectLogsToRerun (const rerun::RecordingStream &rec)
	Redirects logs from the XR_LOG framework to the Rerun logger.

void	addIOOptions (CLI::App &app, std::shared_ptr< IOOptions > ioOptions)

void	addModelOptions (CLI::App &app, std::shared_ptr< ModelOptions > modelOptions)

void	addCalibrationOptions (CLI::App &app, std::shared_ptr< CalibrationConfig > config)

void	addTrackingOptions (CLI::App &app, std::shared_ptr< TrackingConfig > config)

void	addRefineOptions (CLI::App &app, std::shared_ptr< RefineConfig > config)

std::tuple< momentum::Character, momentum::ModelParameters >	loadCalibratedModel (const std::string &modelFile)

std::tuple< momentum::Character, momentum::ModelParameters >	loadCharacterWithIdentity (const ModelOptions &modelFiles)

void	saveMotion (const std::string &outFile, const momentum::Character &character, const momentum::ModelParameters &identity, Eigen::MatrixXf &finalMotion, std::span< const std::vector< momentum::Marker > > markerData, double fps, bool saveMarkerMesh=true)
	Save the given character and motion to a GLB or FBX file.

std::vector< size_t >	sampleFrames (momentum::Character &character, const MatrixXf &initialMotion, std::span< const std::vector< momentum::Marker > > markerData, const ParameterSet &parameters, const size_t frameStride, const size_t numSamples)
	Sample representative frames from motion data to maximize parameter variance.

Eigen::MatrixXf	trackSequence (const std::span< const std::vector< Marker > > markerData, const Character &character, const ParameterSet &globalParams, const MatrixXf &initialMotion, const TrackingConfig &config, float regularizer, const size_t frameStride, bool enforceFloorInFirstFrame, const std::string &firstFramePoseConstraintSet)
	Track motion across multiple frames simultaneously with temporal constraints.

Eigen::MatrixXf	trackSequence (const std::span< const std::vector< Marker > > markerData, const Character &character, const ParameterSet &globalParams, const MatrixXf &initialMotion, const TrackingConfig &config, const std::vector< size_t > &frames, float regularizer, bool enforceFloorInFirstFrame, const std::string &firstFramePoseConstraintSet)
	Track motion across multiple frames simultaneously for specific frame indices.

bool	isGlobalTransformZero (const Eigen::VectorXf &dof, const ParameterSet &rigidParams)
	Check if the global transform is zero by checking if any rigid parameters are non-zero.

Eigen::MatrixXf	trackPosesPerframe (const std::span< const std::vector< Marker > > markerData, const Character &character, const ModelParameters &globalParams, const TrackingConfig &config, const size_t frameStride)
	Track poses independently per frame with fixed character identity.

Eigen::MatrixXf	trackPosesForFrames (const std::span< const std::vector< Marker > > markerData, const Character &character, const MatrixXf &initialMotion, const TrackingConfig &config, const std::vector< size_t > &frameIndices, bool isContinuous)
	Track poses independently for specific frame indices with fixed character identity.

Character	addSkinnedLocatorParametersToTransform (Character character)

void	calibrateModel (const std::span< const std::vector< Marker > > markerData, const CalibrationConfig &config, Character &character, ModelParameters &identity)
	Calibrate character identity parameters (scaling, locators, blend shapes) from marker data.

void	calibrateLocators (const std::span< const std::vector< Marker > > markerData, const CalibrationConfig &config, const ModelParameters &identity, Character &character)
	Calibrate only locator positions with fixed character identity parameters.

MatrixXf	refineMotion (std::span< const std::vector< momentum::Marker > > markerData, const MatrixXf &motion, const RefineConfig &config, momentum::Character &character)
	Refine existing motion by smoothing and optionally recalibrating identity/locators.

std::pair< float, float >	getLocatorError (std::span< const std::vector< momentum::Marker > > markerData, const MatrixXf &motion, momentum::Character &character)
	Compute average and maximum marker tracking errors across all frames.

Eigen::MatrixXf	trackSequence (std::span< const std::vector< momentum::Marker > > markerData, const momentum::Character &character, const momentum::ParameterSet &globalParams, const Eigen::MatrixXf &initialMotion, const TrackingConfig &config, float regularizer=0.0, size_t frameStride=1, bool enforceFloorInFirstFrame=false, const std::string &firstFramePoseConstraintSet="")
	Use multiple frames to solve for global parameters such as body proportions and/or marker offsets together with the motion.

Eigen::MatrixXf	trackSequence (std::span< const std::vector< momentum::Marker > > markerData, const momentum::Character &character, const momentum::ParameterSet &globalParams, const Eigen::MatrixXf &initialMotion, const TrackingConfig &config, const std::vector< size_t > &frames, float regularizer=0.0, bool enforceFloorInFirstFrame=false, const std::string &firstFramePoseConstraintSet="")
	Use multiple frames to solve for global parameters such as body proportions and/or marker offsets together with the motion.

Eigen::MatrixXf	trackPosesPerframe (std::span< const std::vector< momentum::Marker > > markerData, const momentum::Character &character, const momentum::ModelParameters &globalParams, const TrackingConfig &config, size_t frameStride=1)
	Track poses per-frame given a calibrated character.

Eigen::MatrixXf	trackPosesForFrames (std::span< const std::vector< momentum::Marker > > markerData, const momentum::Character &character, const Eigen::MatrixXf &initialMotion, const TrackingConfig &config, const std::vector< size_t > &frameIndices, bool isContinuous=false)
	Track poses for given frames.

void	calibrateModel (std::span< const std::vector< momentum::Marker > > markerData, const CalibrationConfig &config, momentum::Character &character, momentum::ModelParameters &identity)
	Calibrate body proportions and locator offsets of a character from input marker data.

void	calibrateLocators (std::span< const std::vector< momentum::Marker > > markerData, const CalibrationConfig &config, const momentum::ModelParameters &identity, momentum::Character &character)
	Calibrate locator offsets of a character from input identity and marker data.

Eigen::MatrixXf	refineMotion (std::span< const std::vector< momentum::Marker > > markerData, const Eigen::MatrixXf &motion, const RefineConfig &config, momentum::Character &character)

std::pair< float, float >	getLocatorError (std::span< const std::vector< momentum::Marker > > markerData, const Eigen::MatrixXf &motion, momentum::Character &character)
	Get the error of the locator motion vs the markers.

Eigen::MatrixXf	processMarkers (momentum::Character &character, momentum::ModelParameters &identity, const std::vector< std::vector< momentum::Marker > > &markerData, const TrackingConfig &trackingConfig, const CalibrationConfig &calibrationConfig, bool calibrate=true, size_t firstFrame=0, size_t maxFrames=0)
	Processes marker data for a character model.

void	processMarkerFile (const std::string &inputMarkerFile, const std::string &outputFile, const TrackingConfig &trackingConfig, const CalibrationConfig &calibrationConfig, const ModelOptions &modelOptions, bool calibrate, size_t firstFrame=0, size_t maxFrames=0)
	Runs marker tracking on an input marker file (e.g.

std::vector< std::vector< PositionData > >	createConstraintData (const std::span< const std::vector< Marker > > markerData, const LocatorList &locators)

std::vector< std::vector< SkinnedLocatorConstraint > >	createSkinnedConstraintData (const std::span< const std::vector< Marker > > markerData, const SkinnedLocatorList &locators)

std::pair< Eigen::Vector< uint32_t, kMaxSkinJoints >, Eigen::Vector< float, kMaxSkinJoints > >	averageTriangleSkinWeights (const Character &character, int triangleIndex, const Eigen::Vector3f &barycentric)

ClosestPointOnMeshResult	closestPointOnMeshMatchingParent (const momentum::Mesh &mesh, const momentum::SkinWeights &skin, const Eigen::Vector3f &p_world, uint32_t parentIdx, float cutoffWeight=0.1)

momentum::Character	locatorsToSkinnedLocators (const momentum::Character &sourceCharacter, float maxDistance=3.0f)
	Convert locators to skinned locators by finding the closest point on the mesh surface that matches the correct bone index and using the skinned weights from that point.

std::vector< momentum::SkinnedLocatorTriangleConstraintT< float > >	createSkinnedLocatorMeshConstraints (const momentum::Character &character, float targetDepth)

Character	createLocatorCharacter (const Character &sourceCharacter, const std::string &prefix)

LocatorList	extractLocatorsFromCharacter (const Character &locatorCharacter, const CharacterParameters &calibParams)

SkinnedLocatorList	extractSkinnedLocatorsFromCharacter (const Character &locatorCharacter, const CharacterParameters &calibParams)

ModelParameters	extractParameters (const ModelParameters &params, const ParameterSet &parameterSet)

std::tuple< Eigen::VectorXf, LocatorList, SkinnedLocatorList >	extractIdAndLocatorsFromParams (const ModelParameters &param, const Character &sourceCharacter, const Character &targetCharacter)

Mesh	extractBlendShapeFromParams (const momentum::ModelParameters &param, const momentum::Character &sourceCharacter)

void	fillIdentity (const ParameterSet &idSet, const ModelParameters &identity, Eigen::MatrixXf &motionNoId)

void	removeIdentity (const ParameterSet &idSet, const ModelParameters &identity, Eigen::MatrixXf &motionWithId)

ModelParameters	jointIdentityToModelIdentity (const Character &c, const ParameterSet &idSet, const JointParameters &jointIdentity)

std::vector< std::vector< Marker > >	extractMarkersFromMotion (const Character &character, const Eigen::MatrixXf &motion)

std::vector< std::vector< momentum::PositionData > >	createConstraintData (std::span< const std::vector< momentum::Marker > > markerData, const momentum::LocatorList &locators)

std::vector< std::vector< momentum::SkinnedLocatorConstraint > >	createSkinnedConstraintData (std::span< const std::vector< momentum::Marker > > markerData, const momentum::SkinnedLocatorList &locators)

Matrix Utilities
template<typename T >
MatrixX< T >	pseudoInverse (const MatrixX< T > &mat)
	Calculates the pseudo-inverse of a matrix.

template<typename T >
MatrixX< T >	pseudoInverse (const SparseMatrix< T > &mat)
	Calculates the pseudo-inverse of a sparse matrix.

Math Utilities
ParameterSet	allParams ()
	Creates a ParameterSet with all parameters set to active.

template<class T >
T	sqr (const T &x)
	Computes the square of a value.

template<typename T = float>
bool	isApprox (T l, T r, T eps=Eps< T >(1e-4, 1e-6)) noexcept
	Determines if two values are approximately equal within a given tolerance.

Variables
constexpr size_t	kAvxPacketSize = 8

constexpr size_t	kAvxAlignment = kAvxPacketSize * sizeof(float)

constexpr size_t	kSimdPacketSize = drjit::DefaultSize

constexpr size_t	kSimdAlignment = kSimdPacketSize * sizeof(float)

constexpr int	Dynamic = Eigen::Dynamic

constexpr size_t	kMaxModelParams = 2048

template<typename T >
const std::array< Vector3< T >, 3 >	RotationAxis

constexpr float	kDefaultExtrapolateFactor = 0.8f

constexpr float	kDefaultExtrapolateMaxDelta = 0.4f

constexpr size_t	kParametersPerJoint = 7

constexpr std::array< const char *, kParametersPerJoint >	kJointParameterNames {"tx", "ty", "tz", "rx", "ry", "rz", "sc"}

constexpr size_t	kInvalidIndex = std::numeric_limits<size_t>::max()

constexpr float	kPositionWeight = 1e-4f

constexpr size_t	kAllFrames = SIZE_MAX

constexpr const char *	kMomentumMarkersRootProperty = "Momentum_Markers_Root"

constexpr const char *	kMomentumMarkerProperty = "Momentum_Marker"

constexpr uint32_t	kInvalidTexCoord = static_cast<uint32_t>(-1)

Geometry Utilities
enum class	EulerConvention { Intrinsic , Extrinsic }
	The Euler angles convention. More...

template<typename T >
Quaternion< T >	quaternionExpMap (const Vector3< T > &v)
	Computes the exponential map from a rotation vector (axis-angle in R^3) to a quaternion.

template<typename T >
Vector3< T >	quaternionLogMap (const Quaternion< T > &q)
	Computes the logarithmic map from a quaternion to a rotation vector (axis-angle in R^3).

template<typename T >
Eigen::Matrix< T, 3, 4 >	quaternionLogMapDerivative (const Quaternion< T > &q)
	Computes the derivative of the logmap with respect to quaternion components.

template<typename T >
Vector3< T >	rotationMatrixToEuler (const Matrix3< T > &m, int axis0, int axis1, int axis2, EulerConvention convention=EulerConvention::Intrinsic)
	Converts rotation matrix to Euler angles.

template<typename T >
Vector3< T >	rotationMatrixToEulerXYZ (const Matrix3< T > &m, EulerConvention convention=EulerConvention::Intrinsic)
	An optimized version of rotationMatrixToEuler(m, 0, 1, 2, convention) or rotationMatrixToEuler(m, 2, 1, 0, convention).reverse().

template<typename T >
Vector3< T >	rotationMatrixToEulerZYX (const Matrix3< T > &m, EulerConvention convention=EulerConvention::Intrinsic)
	An optimized version of rotationMatrixToEuler(m, 2, 1, 0, convention) or rotationMatrixToEuler(m, 0, 1, 2, convention).reverse().

template<typename T >
Quaternion< T >	eulerToQuaternion (const Vector3< T > &angles, int axis0, int axis1, int axis2, EulerConvention convention=EulerConvention::Intrinsic)
	Converts Euler angles to quaternion.

template<typename T >
Matrix3< T >	eulerToRotationMatrix (const Vector3< T > &angles, int axis0, int axis1, int axis2, EulerConvention convention=EulerConvention::Intrinsic)
	Converts Euler angles to rotation matrix.

template<typename T >
Matrix3< T >	eulerXYZToRotationMatrix (const Vector3< T > &angles, EulerConvention convention=EulerConvention::Intrinsic)
	An optimized version of eulerToRotationMatrix(angles, 0, 1, 2, convention) or eulerToRotationMatrix(angles.reverse(), 2, 1, 0, convention).

template<typename T >
Matrix3< T >	eulerZYXToRotationMatrix (const Vector3< T > &angles, EulerConvention convention=EulerConvention::Intrinsic)
	An optimized version of eulerToRotationMatrix(angles, 2, 1, 0, convention) or eulerToRotationMatrix(angles.reverse(), 0, 1, 2, convention).

template<typename T >
Vector3< T >	quaternionToEuler (const Quaternion< T > &q)
	Converts a quaternion to Euler angles using the Extrinsic XYZ convention.

Quaternionf	quaternionAverage (std::span< const Quaternionf > q, std::span< const float > w=std::vector< float >())
	Computes the weighted average of multiple quaternions.

template<typename T >
std::tuple< bool, T, Eigen::Vector2< T > >	closestPointsOnSegments (const Eigen::Vector3< T > &o1, const Eigen::Vector3< T > &d1, const Eigen::Vector3< T > &o2, const Eigen::Vector3< T > &d2, T maxDist=std::numeric_limits< T >::max())
	Returns the closest points on two line segments where the line segments are represented in origin and direction.

template<typename T >
T	rotationMatrixToOneAxisEuler (const Matrix3< T > &m, int axis0)
	Fits a single-axis Euler rotation to a rotation matrix.

template<typename T >
Vector2< T >	rotationMatrixToTwoAxisEuler (const Matrix3< T > &m, int axis0, int axis1)
	Fits a two-axis Euler rotation to a rotation matrix.

template<typename T >
Eigen::Matrix< T, 3, 3 >	crossProductMatrix (const Eigen::Vector3< T > &v)
	Creates a skew-symmetric matrix for computing cross products.

Typedef Documentation

◆ Affine3

template<typename T >

using momentum::Affine3 = typedef Eigen::Transform<T, 3, Eigen::Affine>

Definition at line 386 of file types.h.

◆ Affine3d

using momentum::Affine3d = typedef Affine3<double>

Definition at line 388 of file types.h.

◆ Affine3f

using momentum::Affine3f = typedef Affine3<float>

Definition at line 387 of file types.h.

◆ AimData

using momentum::AimData = typedef AimDataT<float>

Definition at line 65 of file fwd.h.

◆ AimData_const_p

using momentum::AimData_const_p = typedef ::std::shared_ptr<const AimData>

Definition at line 71 of file fwd.h.

◆ AimData_const_u

using momentum::AimData_const_u = typedef ::std::unique_ptr<const AimData>

Definition at line 72 of file fwd.h.

◆ AimData_const_w

using momentum::AimData_const_w = typedef ::std::weak_ptr<const AimData>

Definition at line 73 of file fwd.h.

◆ AimData_p

using momentum::AimData_p = typedef ::std::shared_ptr<AimData>

Definition at line 68 of file fwd.h.

◆ AimData_u

using momentum::AimData_u = typedef ::std::unique_ptr<AimData>

Definition at line 69 of file fwd.h.

◆ AimData_w

using momentum::AimData_w = typedef ::std::weak_ptr<AimData>

Definition at line 70 of file fwd.h.

◆ AimDatad

using momentum::AimDatad = typedef AimDataT<double>

Definition at line 66 of file fwd.h.

◆ AimDatad_const_p

using momentum::AimDatad_const_p = typedef ::std::shared_ptr<const AimDatad>

Definition at line 78 of file fwd.h.

◆ AimDatad_const_u

using momentum::AimDatad_const_u = typedef ::std::unique_ptr<const AimDatad>

Definition at line 79 of file fwd.h.

◆ AimDatad_const_w

using momentum::AimDatad_const_w = typedef ::std::weak_ptr<const AimDatad>

Definition at line 80 of file fwd.h.

◆ AimDatad_p

using momentum::AimDatad_p = typedef ::std::shared_ptr<AimDatad>

Definition at line 75 of file fwd.h.

◆ AimDatad_u

using momentum::AimDatad_u = typedef ::std::unique_ptr<AimDatad>

Definition at line 76 of file fwd.h.

◆ AimDatad_w

using momentum::AimDatad_w = typedef ::std::weak_ptr<AimDatad>

Definition at line 77 of file fwd.h.

◆ AimDirErrorFunction

using momentum::AimDirErrorFunction = typedef AimDirErrorFunctionT<float>

Definition at line 339 of file fwd.h.

◆ AimDirErrorFunction_const_p

using momentum::AimDirErrorFunction_const_p = typedef ::std::shared_ptr<const AimDirErrorFunction>

Definition at line 345 of file fwd.h.

◆ AimDirErrorFunction_const_u

using momentum::AimDirErrorFunction_const_u = typedef ::std::unique_ptr<const AimDirErrorFunction>

Definition at line 346 of file fwd.h.

◆ AimDirErrorFunction_const_w

using momentum::AimDirErrorFunction_const_w = typedef ::std::weak_ptr<const AimDirErrorFunction>

Definition at line 347 of file fwd.h.

◆ AimDirErrorFunction_p

using momentum::AimDirErrorFunction_p = typedef ::std::shared_ptr<AimDirErrorFunction>

Definition at line 342 of file fwd.h.

◆ AimDirErrorFunction_u

using momentum::AimDirErrorFunction_u = typedef ::std::unique_ptr<AimDirErrorFunction>

Definition at line 343 of file fwd.h.

◆ AimDirErrorFunction_w

using momentum::AimDirErrorFunction_w = typedef ::std::weak_ptr<AimDirErrorFunction>

Definition at line 344 of file fwd.h.

◆ AimDirErrorFunctiond

using momentum::AimDirErrorFunctiond = typedef AimDirErrorFunctionT<double>

Definition at line 340 of file fwd.h.

◆ AimDirErrorFunctiond_const_p

using momentum::AimDirErrorFunctiond_const_p = typedef ::std::shared_ptr<const AimDirErrorFunctiond>

Definition at line 352 of file fwd.h.

◆ AimDirErrorFunctiond_const_u

using momentum::AimDirErrorFunctiond_const_u = typedef ::std::unique_ptr<const AimDirErrorFunctiond>

Definition at line 353 of file fwd.h.

◆ AimDirErrorFunctiond_const_w

using momentum::AimDirErrorFunctiond_const_w = typedef ::std::weak_ptr<const AimDirErrorFunctiond>

Definition at line 354 of file fwd.h.

◆ AimDirErrorFunctiond_p

using momentum::AimDirErrorFunctiond_p = typedef ::std::shared_ptr<AimDirErrorFunctiond>

Definition at line 349 of file fwd.h.

◆ AimDirErrorFunctiond_u

using momentum::AimDirErrorFunctiond_u = typedef ::std::unique_ptr<AimDirErrorFunctiond>

Definition at line 350 of file fwd.h.

◆ AimDirErrorFunctiond_w

using momentum::AimDirErrorFunctiond_w = typedef ::std::weak_ptr<AimDirErrorFunctiond>

Definition at line 351 of file fwd.h.

◆ AimDistErrorFunction

using momentum::AimDistErrorFunction = typedef AimDistErrorFunctionT<float>

Definition at line 358 of file fwd.h.

◆ AimDistErrorFunction_const_p

using momentum::AimDistErrorFunction_const_p = typedef ::std::shared_ptr<const AimDistErrorFunction>

Definition at line 364 of file fwd.h.

◆ AimDistErrorFunction_const_u

using momentum::AimDistErrorFunction_const_u = typedef ::std::unique_ptr<const AimDistErrorFunction>

Definition at line 365 of file fwd.h.

◆ AimDistErrorFunction_const_w

using momentum::AimDistErrorFunction_const_w = typedef ::std::weak_ptr<const AimDistErrorFunction>

Definition at line 366 of file fwd.h.

◆ AimDistErrorFunction_p

using momentum::AimDistErrorFunction_p = typedef ::std::shared_ptr<AimDistErrorFunction>

Definition at line 361 of file fwd.h.

◆ AimDistErrorFunction_u

using momentum::AimDistErrorFunction_u = typedef ::std::unique_ptr<AimDistErrorFunction>

Definition at line 362 of file fwd.h.

◆ AimDistErrorFunction_w

using momentum::AimDistErrorFunction_w = typedef ::std::weak_ptr<AimDistErrorFunction>

Definition at line 363 of file fwd.h.

◆ AimDistErrorFunctiond

using momentum::AimDistErrorFunctiond = typedef AimDistErrorFunctionT<double>

Definition at line 359 of file fwd.h.

◆ AimDistErrorFunctiond_const_p

using momentum::AimDistErrorFunctiond_const_p = typedef ::std::shared_ptr<const AimDistErrorFunctiond>

Definition at line 371 of file fwd.h.

◆ AimDistErrorFunctiond_const_u

using momentum::AimDistErrorFunctiond_const_u = typedef ::std::unique_ptr<const AimDistErrorFunctiond>

Definition at line 372 of file fwd.h.

◆ AimDistErrorFunctiond_const_w

using momentum::AimDistErrorFunctiond_const_w = typedef ::std::weak_ptr<const AimDistErrorFunctiond>

Definition at line 373 of file fwd.h.

◆ AimDistErrorFunctiond_p

using momentum::AimDistErrorFunctiond_p = typedef ::std::shared_ptr<AimDistErrorFunctiond>

Definition at line 368 of file fwd.h.

◆ AimDistErrorFunctiond_u

using momentum::AimDistErrorFunctiond_u = typedef ::std::unique_ptr<AimDistErrorFunctiond>

Definition at line 369 of file fwd.h.

◆ AimDistErrorFunctiond_w

using momentum::AimDistErrorFunctiond_w = typedef ::std::weak_ptr<AimDistErrorFunctiond>

Definition at line 370 of file fwd.h.

◆ AngleAxis

template<typename T >

using momentum::AngleAxis = typedef Eigen::AngleAxis<T>

Definition at line 366 of file types.h.

◆ AngleAxisd

using momentum::AngleAxisd = typedef AngleAxis<double>

Definition at line 368 of file types.h.

◆ AngleAxisf

using momentum::AngleAxisf = typedef AngleAxis<float>

Definition at line 367 of file types.h.

◆ BlendShape_const_p

using momentum::BlendShape_const_p = typedef ::std::shared_ptr<const BlendShape>

Definition at line 23 of file fwd.h.

◆ BlendShape_const_u

using momentum::BlendShape_const_u = typedef ::std::unique_ptr<const BlendShape>

Definition at line 24 of file fwd.h.

◆ BlendShape_const_w

using momentum::BlendShape_const_w = typedef ::std::weak_ptr<const BlendShape>

Definition at line 25 of file fwd.h.

◆ BlendShape_p

using momentum::BlendShape_p = typedef ::std::shared_ptr<BlendShape>

Definition at line 20 of file fwd.h.

◆ BlendShape_u

using momentum::BlendShape_u = typedef ::std::unique_ptr<BlendShape>

Definition at line 21 of file fwd.h.

◆ BlendShape_w

using momentum::BlendShape_w = typedef ::std::weak_ptr<BlendShape>

Definition at line 22 of file fwd.h.

◆ BlendShapeBase_const_p

using momentum::BlendShapeBase_const_p = typedef ::std::shared_ptr<const BlendShapeBase>

Definition at line 32 of file fwd.h.

◆ BlendShapeBase_const_u

using momentum::BlendShapeBase_const_u = typedef ::std::unique_ptr<const BlendShapeBase>

Definition at line 33 of file fwd.h.

◆ BlendShapeBase_const_w

using momentum::BlendShapeBase_const_w = typedef ::std::weak_ptr<const BlendShapeBase>

Definition at line 34 of file fwd.h.

◆ BlendShapeBase_p

using momentum::BlendShapeBase_p = typedef ::std::shared_ptr<BlendShapeBase>

Definition at line 29 of file fwd.h.

◆ BlendShapeBase_u

using momentum::BlendShapeBase_u = typedef ::std::unique_ptr<BlendShapeBase>

Definition at line 30 of file fwd.h.

◆ BlendShapeBase_w

using momentum::BlendShapeBase_w = typedef ::std::weak_ptr<BlendShapeBase>

Definition at line 31 of file fwd.h.

◆ BlendWeights

using momentum::BlendWeights = typedef BlendWeightsT<float>

Definition at line 119 of file types.h.

◆ BlendWeightsd

using momentum::BlendWeightsd = typedef BlendWeightsT<double>

Definition at line 120 of file types.h.

◆ Box

template<typename Scalar , int Dim>

using momentum::Box = typedef Eigen::AlignedBox<Scalar, Dim>

Definition at line 56 of file types.h.

◆ Box2

template<typename T >

using momentum::Box2 = typedef Eigen::AlignedBox<T, 2>

Definition at line 68 of file types.h.

◆ Box2d

using momentum::Box2d = typedef Box2<double>

Definition at line 75 of file types.h.

◆ Box2f

using momentum::Box2f = typedef Box2<float>

Definition at line 72 of file types.h.

◆ Box2i

using momentum::Box2i = typedef Box2<std::int32_t>

Definition at line 78 of file types.h.

◆ Box3

template<typename T >

using momentum::Box3 = typedef Eigen::AlignedBox<T, 3>

Definition at line 70 of file types.h.

◆ Box3d

using momentum::Box3d = typedef Box3<double>

Definition at line 76 of file types.h.

◆ Box3f

using momentum::Box3f = typedef Box3<float>

Definition at line 73 of file types.h.

◆ Box3i

using momentum::Box3i = typedef Box3<std::int32_t>

Definition at line 79 of file types.h.

◆ Boxd

template<int Dim>

using momentum::Boxd = typedef Eigen::AlignedBox<double, Dim>

Definition at line 62 of file types.h.

◆ Boxf

template<int Dim>

using momentum::Boxf = typedef Eigen::AlignedBox<float, Dim>

Definition at line 59 of file types.h.

◆ Boxi

template<int Dim>

using momentum::Boxi = typedef Eigen::AlignedBox<std::int32_t, Dim>

Definition at line 65 of file types.h.

◆ Character

using momentum::Character = typedef CharacterT<float>

Definition at line 74 of file fwd.h.

◆ Character_const_p

using momentum::Character_const_p = typedef ::std::shared_ptr<const Character>

Definition at line 80 of file fwd.h.

◆ Character_const_u

using momentum::Character_const_u = typedef ::std::unique_ptr<const Character>

Definition at line 81 of file fwd.h.

◆ Character_const_w

using momentum::Character_const_w = typedef ::std::weak_ptr<const Character>

Definition at line 82 of file fwd.h.

◆ Character_p

using momentum::Character_p = typedef ::std::shared_ptr<Character>

Definition at line 77 of file fwd.h.

◆ Character_u

using momentum::Character_u = typedef ::std::unique_ptr<Character>

Definition at line 78 of file fwd.h.

◆ Character_w

using momentum::Character_w = typedef ::std::weak_ptr<Character>

Definition at line 79 of file fwd.h.

◆ Characterd

using momentum::Characterd = typedef CharacterT<double>

Definition at line 75 of file fwd.h.

◆ Characterd_const_p

using momentum::Characterd_const_p = typedef ::std::shared_ptr<const Characterd>

Definition at line 87 of file fwd.h.

◆ Characterd_const_u

using momentum::Characterd_const_u = typedef ::std::unique_ptr<const Characterd>

Definition at line 88 of file fwd.h.

◆ Characterd_const_w

using momentum::Characterd_const_w = typedef ::std::weak_ptr<const Characterd>

Definition at line 89 of file fwd.h.

◆ Characterd_p

using momentum::Characterd_p = typedef ::std::shared_ptr<Characterd>

Definition at line 84 of file fwd.h.

◆ Characterd_u

using momentum::Characterd_u = typedef ::std::unique_ptr<Characterd>

Definition at line 85 of file fwd.h.

◆ Characterd_w

using momentum::Characterd_w = typedef ::std::weak_ptr<Characterd>

Definition at line 86 of file fwd.h.

◆ CharacterParameters

using momentum::CharacterParameters = typedef CharacterParametersT<float>

Definition at line 183 of file types.h.

◆ CharacterParametersd

using momentum::CharacterParametersd = typedef CharacterParametersT<double>

Definition at line 184 of file types.h.

◆ CharacterState

using momentum::CharacterState = typedef CharacterStateT<float>

Definition at line 93 of file fwd.h.

◆ CharacterState_const_p

using momentum::CharacterState_const_p = typedef ::std::shared_ptr<const CharacterState>

Definition at line 99 of file fwd.h.

◆ CharacterState_const_u

using momentum::CharacterState_const_u = typedef ::std::unique_ptr<const CharacterState>

Definition at line 100 of file fwd.h.

◆ CharacterState_const_w

using momentum::CharacterState_const_w = typedef ::std::weak_ptr<const CharacterState>

Definition at line 101 of file fwd.h.

◆ CharacterState_p

using momentum::CharacterState_p = typedef ::std::shared_ptr<CharacterState>

Definition at line 96 of file fwd.h.

◆ CharacterState_u

using momentum::CharacterState_u = typedef ::std::unique_ptr<CharacterState>

Definition at line 97 of file fwd.h.

◆ CharacterState_w

using momentum::CharacterState_w = typedef ::std::weak_ptr<CharacterState>

Definition at line 98 of file fwd.h.

◆ CharacterStated

using momentum::CharacterStated = typedef CharacterStateT<double>

Definition at line 94 of file fwd.h.

◆ CharacterStated_const_p

using momentum::CharacterStated_const_p = typedef ::std::shared_ptr<const CharacterStated>

Definition at line 106 of file fwd.h.

◆ CharacterStated_const_u

using momentum::CharacterStated_const_u = typedef ::std::unique_ptr<const CharacterStated>

Definition at line 107 of file fwd.h.

◆ CharacterStated_const_w

using momentum::CharacterStated_const_w = typedef ::std::weak_ptr<const CharacterStated>

Definition at line 108 of file fwd.h.

◆ CharacterStated_p

using momentum::CharacterStated_p = typedef ::std::shared_ptr<CharacterStated>

Definition at line 103 of file fwd.h.

◆ CharacterStated_u

using momentum::CharacterStated_u = typedef ::std::unique_ptr<CharacterStated>

Definition at line 104 of file fwd.h.

◆ CharacterStated_w

using momentum::CharacterStated_w = typedef ::std::weak_ptr<CharacterStated>

Definition at line 105 of file fwd.h.

◆ CollisionErrorFunction

using momentum::CollisionErrorFunction = typedef CollisionErrorFunctionT<float>

Definition at line 377 of file fwd.h.

◆ CollisionErrorFunction_const_p

using momentum::CollisionErrorFunction_const_p = typedef ::std::shared_ptr<const CollisionErrorFunction>

Definition at line 383 of file fwd.h.

◆ CollisionErrorFunction_const_u

using momentum::CollisionErrorFunction_const_u = typedef ::std::unique_ptr<const CollisionErrorFunction>

Definition at line 384 of file fwd.h.

◆ CollisionErrorFunction_const_w

using momentum::CollisionErrorFunction_const_w = typedef ::std::weak_ptr<const CollisionErrorFunction>

Definition at line 385 of file fwd.h.

◆ CollisionErrorFunction_p

using momentum::CollisionErrorFunction_p = typedef ::std::shared_ptr<CollisionErrorFunction>

Definition at line 380 of file fwd.h.

◆ CollisionErrorFunction_u

using momentum::CollisionErrorFunction_u = typedef ::std::unique_ptr<CollisionErrorFunction>

Definition at line 381 of file fwd.h.

◆ CollisionErrorFunction_w

using momentum::CollisionErrorFunction_w = typedef ::std::weak_ptr<CollisionErrorFunction>

Definition at line 382 of file fwd.h.

◆ CollisionErrorFunctiond

using momentum::CollisionErrorFunctiond = typedef CollisionErrorFunctionT<double>

Definition at line 378 of file fwd.h.

◆ CollisionErrorFunctiond_const_p

using momentum::CollisionErrorFunctiond_const_p = typedef ::std::shared_ptr<const CollisionErrorFunctiond>

Definition at line 390 of file fwd.h.

◆ CollisionErrorFunctiond_const_u

using momentum::CollisionErrorFunctiond_const_u = typedef ::std::unique_ptr<const CollisionErrorFunctiond>

Definition at line 391 of file fwd.h.

◆ CollisionErrorFunctiond_const_w

using momentum::CollisionErrorFunctiond_const_w = typedef ::std::weak_ptr<const CollisionErrorFunctiond>

Definition at line 392 of file fwd.h.

◆ CollisionErrorFunctiond_p

using momentum::CollisionErrorFunctiond_p = typedef ::std::shared_ptr<CollisionErrorFunctiond>

Definition at line 387 of file fwd.h.

◆ CollisionErrorFunctiond_u

using momentum::CollisionErrorFunctiond_u = typedef ::std::unique_ptr<CollisionErrorFunctiond>

Definition at line 388 of file fwd.h.

◆ CollisionErrorFunctiond_w

using momentum::CollisionErrorFunctiond_w = typedef ::std::weak_ptr<CollisionErrorFunctiond>

Definition at line 389 of file fwd.h.

◆ CollisionErrorFunctionStateless

using momentum::CollisionErrorFunctionStateless = typedef CollisionErrorFunctionStatelessT<float>

Definition at line 396 of file fwd.h.

◆ CollisionErrorFunctionStateless_const_p

using momentum::CollisionErrorFunctionStateless_const_p = typedef ::std::shared_ptr<const CollisionErrorFunctionStateless>

Definition at line 402 of file fwd.h.

◆ CollisionErrorFunctionStateless_const_u

using momentum::CollisionErrorFunctionStateless_const_u = typedef ::std::unique_ptr<const CollisionErrorFunctionStateless>

Definition at line 404 of file fwd.h.

◆ CollisionErrorFunctionStateless_const_w

using momentum::CollisionErrorFunctionStateless_const_w = typedef ::std::weak_ptr<const CollisionErrorFunctionStateless>

Definition at line 406 of file fwd.h.

◆ CollisionErrorFunctionStateless_p

using momentum::CollisionErrorFunctionStateless_p = typedef ::std::shared_ptr<CollisionErrorFunctionStateless>

Definition at line 399 of file fwd.h.

◆ CollisionErrorFunctionStateless_u

using momentum::CollisionErrorFunctionStateless_u = typedef ::std::unique_ptr<CollisionErrorFunctionStateless>

Definition at line 400 of file fwd.h.

◆ CollisionErrorFunctionStateless_w

using momentum::CollisionErrorFunctionStateless_w = typedef ::std::weak_ptr<CollisionErrorFunctionStateless>

Definition at line 401 of file fwd.h.

◆ CollisionErrorFunctionStatelessd

using momentum::CollisionErrorFunctionStatelessd = typedef CollisionErrorFunctionStatelessT<double>

Definition at line 397 of file fwd.h.

◆ CollisionErrorFunctionStatelessd_const_p

using momentum::CollisionErrorFunctionStatelessd_const_p = typedef ::std::shared_ptr<const CollisionErrorFunctionStatelessd>

Definition at line 412 of file fwd.h.

◆ CollisionErrorFunctionStatelessd_const_u

using momentum::CollisionErrorFunctionStatelessd_const_u = typedef ::std::unique_ptr<const CollisionErrorFunctionStatelessd>

Definition at line 414 of file fwd.h.

◆ CollisionErrorFunctionStatelessd_const_w

using momentum::CollisionErrorFunctionStatelessd_const_w = typedef ::std::weak_ptr<const CollisionErrorFunctionStatelessd>

Definition at line 416 of file fwd.h.

◆ CollisionErrorFunctionStatelessd_p

using momentum::CollisionErrorFunctionStatelessd_p = typedef ::std::shared_ptr<CollisionErrorFunctionStatelessd>

Definition at line 409 of file fwd.h.

◆ CollisionErrorFunctionStatelessd_u

using momentum::CollisionErrorFunctionStatelessd_u = typedef ::std::unique_ptr<CollisionErrorFunctionStatelessd>

Definition at line 410 of file fwd.h.

◆ CollisionErrorFunctionStatelessd_w

using momentum::CollisionErrorFunctionStatelessd_w = typedef ::std::weak_ptr<CollisionErrorFunctionStatelessd>

Definition at line 411 of file fwd.h.

◆ CollisionGeometry

using momentum::CollisionGeometry = typedef CollisionGeometryT<float>

Definition at line 74 of file collision_geometry.h.

◆ CollisionGeometryd

using momentum::CollisionGeometryd = typedef CollisionGeometryT<double>

Definition at line 75 of file collision_geometry.h.

◆ CollisionGeometryState

using momentum::CollisionGeometryState = typedef CollisionGeometryStateT<float>

Definition at line 112 of file fwd.h.

◆ CollisionGeometryState_const_p

using momentum::CollisionGeometryState_const_p = typedef ::std::shared_ptr<const CollisionGeometryState>

Definition at line 118 of file fwd.h.

◆ CollisionGeometryState_const_u

using momentum::CollisionGeometryState_const_u = typedef ::std::unique_ptr<const CollisionGeometryState>

Definition at line 119 of file fwd.h.

◆ CollisionGeometryState_const_w

using momentum::CollisionGeometryState_const_w = typedef ::std::weak_ptr<const CollisionGeometryState>

Definition at line 120 of file fwd.h.

◆ CollisionGeometryState_p

using momentum::CollisionGeometryState_p = typedef ::std::shared_ptr<CollisionGeometryState>

Definition at line 115 of file fwd.h.

◆ CollisionGeometryState_u

using momentum::CollisionGeometryState_u = typedef ::std::unique_ptr<CollisionGeometryState>

Definition at line 116 of file fwd.h.

◆ CollisionGeometryState_w

using momentum::CollisionGeometryState_w = typedef ::std::weak_ptr<CollisionGeometryState>

Definition at line 117 of file fwd.h.

◆ CollisionGeometryStated

using momentum::CollisionGeometryStated = typedef CollisionGeometryStateT<double>

Definition at line 113 of file fwd.h.

◆ CollisionGeometryStated_const_p

using momentum::CollisionGeometryStated_const_p = typedef ::std::shared_ptr<const CollisionGeometryStated>

Definition at line 125 of file fwd.h.

◆ CollisionGeometryStated_const_u

using momentum::CollisionGeometryStated_const_u = typedef ::std::unique_ptr<const CollisionGeometryStated>

Definition at line 126 of file fwd.h.

◆ CollisionGeometryStated_const_w

using momentum::CollisionGeometryStated_const_w = typedef ::std::weak_ptr<const CollisionGeometryStated>

Definition at line 127 of file fwd.h.

◆ CollisionGeometryStated_p

using momentum::CollisionGeometryStated_p = typedef ::std::shared_ptr<CollisionGeometryStated>

Definition at line 122 of file fwd.h.

◆ CollisionGeometryStated_u

using momentum::CollisionGeometryStated_u = typedef ::std::unique_ptr<CollisionGeometryStated>

Definition at line 123 of file fwd.h.

◆ CollisionGeometryStated_w

using momentum::CollisionGeometryStated_w = typedef ::std::weak_ptr<CollisionGeometryStated>

Definition at line 124 of file fwd.h.

◆ CollisionGeometryT

template<typename S >

using momentum::CollisionGeometryT = typedef std::vector<TaperedCapsuleT<S> >

Collection of tapered capsules representing a character's collision geometry.

Definition at line 72 of file collision_geometry.h.

◆ ColorArray

using momentum::ColorArray = typedef Matrix3Xb

Definition at line 398 of file types.h.

◆ ConstraintData_const_p

using momentum::ConstraintData_const_p = typedef ::std::shared_ptr<const ConstraintData>

Definition at line 23 of file fwd.h.

◆ ConstraintData_const_u

using momentum::ConstraintData_const_u = typedef ::std::unique_ptr<const ConstraintData>

Definition at line 24 of file fwd.h.

◆ ConstraintData_const_w

using momentum::ConstraintData_const_w = typedef ::std::weak_ptr<const ConstraintData>

Definition at line 25 of file fwd.h.

◆ ConstraintData_p

using momentum::ConstraintData_p = typedef ::std::shared_ptr<ConstraintData>

Definition at line 20 of file fwd.h.

◆ ConstraintData_u

using momentum::ConstraintData_u = typedef ::std::unique_ptr<ConstraintData>

Definition at line 21 of file fwd.h.

◆ ConstraintData_w

using momentum::ConstraintData_w = typedef ::std::weak_ptr<ConstraintData>

Definition at line 22 of file fwd.h.

◆ ConstraintDataList

using momentum::ConstraintDataList = typedef std::vector<ConstraintData>

A list of ConstraintData.

Definition at line 34 of file constraint_error_function.h.

◆ DistanceErrorFunction

using momentum::DistanceErrorFunction = typedef DistanceErrorFunctionT<float>

Definition at line 421 of file fwd.h.

◆ DistanceErrorFunction_const_p

using momentum::DistanceErrorFunction_const_p = typedef ::std::shared_ptr<const DistanceErrorFunction>

Definition at line 427 of file fwd.h.

◆ DistanceErrorFunction_const_u

using momentum::DistanceErrorFunction_const_u = typedef ::std::unique_ptr<const DistanceErrorFunction>

Definition at line 428 of file fwd.h.

◆ DistanceErrorFunction_const_w

using momentum::DistanceErrorFunction_const_w = typedef ::std::weak_ptr<const DistanceErrorFunction>

Definition at line 429 of file fwd.h.

◆ DistanceErrorFunction_p

using momentum::DistanceErrorFunction_p = typedef ::std::shared_ptr<DistanceErrorFunction>

Definition at line 424 of file fwd.h.

◆ DistanceErrorFunction_u

using momentum::DistanceErrorFunction_u = typedef ::std::unique_ptr<DistanceErrorFunction>

Definition at line 425 of file fwd.h.

◆ DistanceErrorFunction_w

using momentum::DistanceErrorFunction_w = typedef ::std::weak_ptr<DistanceErrorFunction>

Definition at line 426 of file fwd.h.

◆ DistanceErrorFunctiond

using momentum::DistanceErrorFunctiond = typedef DistanceErrorFunctionT<double>

Definition at line 422 of file fwd.h.

◆ DistanceErrorFunctiond_const_p

using momentum::DistanceErrorFunctiond_const_p = typedef ::std::shared_ptr<const DistanceErrorFunctiond>

Definition at line 434 of file fwd.h.

◆ DistanceErrorFunctiond_const_u

using momentum::DistanceErrorFunctiond_const_u = typedef ::std::unique_ptr<const DistanceErrorFunctiond>

Definition at line 435 of file fwd.h.

◆ DistanceErrorFunctiond_const_w

using momentum::DistanceErrorFunctiond_const_w = typedef ::std::weak_ptr<const DistanceErrorFunctiond>

Definition at line 436 of file fwd.h.

◆ DistanceErrorFunctiond_p

using momentum::DistanceErrorFunctiond_p = typedef ::std::shared_ptr<DistanceErrorFunctiond>

Definition at line 431 of file fwd.h.

◆ DistanceErrorFunctiond_u

using momentum::DistanceErrorFunctiond_u = typedef ::std::unique_ptr<DistanceErrorFunctiond>

Definition at line 432 of file fwd.h.

◆ DistanceErrorFunctiond_w

using momentum::DistanceErrorFunctiond_w = typedef ::std::weak_ptr<DistanceErrorFunctiond>

Definition at line 433 of file fwd.h.

◆ DoubleP

using momentum::DoubleP = typedef Packet<double>

Definition at line 41 of file simd.h.

◆ ErrorFunctionDerivatives

using momentum::ErrorFunctionDerivatives = typedef ErrorFunctionDerivativesT<float>

Definition at line 20 of file fwd.h.

◆ ErrorFunctionDerivatives_const_p

using momentum::ErrorFunctionDerivatives_const_p = typedef ::std::shared_ptr<const ErrorFunctionDerivatives>

Definition at line 26 of file fwd.h.

◆ ErrorFunctionDerivatives_const_u

using momentum::ErrorFunctionDerivatives_const_u = typedef ::std::unique_ptr<const ErrorFunctionDerivatives>

Definition at line 27 of file fwd.h.

◆ ErrorFunctionDerivatives_const_w

using momentum::ErrorFunctionDerivatives_const_w = typedef ::std::weak_ptr<const ErrorFunctionDerivatives>

Definition at line 28 of file fwd.h.

◆ ErrorFunctionDerivatives_p

using momentum::ErrorFunctionDerivatives_p = typedef ::std::shared_ptr<ErrorFunctionDerivatives>

Definition at line 23 of file fwd.h.

◆ ErrorFunctionDerivatives_u

using momentum::ErrorFunctionDerivatives_u = typedef ::std::unique_ptr<ErrorFunctionDerivatives>

Definition at line 24 of file fwd.h.

◆ ErrorFunctionDerivatives_w

using momentum::ErrorFunctionDerivatives_w = typedef ::std::weak_ptr<ErrorFunctionDerivatives>

Definition at line 25 of file fwd.h.

◆ ErrorFunctionDerivativesd

using momentum::ErrorFunctionDerivativesd = typedef ErrorFunctionDerivativesT<double>

Definition at line 21 of file fwd.h.

◆ ErrorFunctionDerivativesd_const_p

using momentum::ErrorFunctionDerivativesd_const_p = typedef ::std::shared_ptr<const ErrorFunctionDerivativesd>

Definition at line 33 of file fwd.h.

◆ ErrorFunctionDerivativesd_const_u

using momentum::ErrorFunctionDerivativesd_const_u = typedef ::std::unique_ptr<const ErrorFunctionDerivativesd>

Definition at line 34 of file fwd.h.

◆ ErrorFunctionDerivativesd_const_w

using momentum::ErrorFunctionDerivativesd_const_w = typedef ::std::weak_ptr<const ErrorFunctionDerivativesd>

Definition at line 35 of file fwd.h.

◆ ErrorFunctionDerivativesd_p

using momentum::ErrorFunctionDerivativesd_p = typedef ::std::shared_ptr<ErrorFunctionDerivativesd>

Definition at line 30 of file fwd.h.

◆ ErrorFunctionDerivativesd_u

using momentum::ErrorFunctionDerivativesd_u = typedef ::std::unique_ptr<ErrorFunctionDerivativesd>

Definition at line 31 of file fwd.h.

◆ ErrorFunctionDerivativesd_w

using momentum::ErrorFunctionDerivativesd_w = typedef ::std::weak_ptr<ErrorFunctionDerivativesd>

Definition at line 32 of file fwd.h.

◆ FixedAxisAngleErrorFunction

using momentum::FixedAxisAngleErrorFunction = typedef FixedAxisAngleErrorFunctionT<float>

Definition at line 440 of file fwd.h.

◆ FixedAxisAngleErrorFunction_const_p

using momentum::FixedAxisAngleErrorFunction_const_p = typedef ::std::shared_ptr<const FixedAxisAngleErrorFunction>

Definition at line 446 of file fwd.h.

◆ FixedAxisAngleErrorFunction_const_u

using momentum::FixedAxisAngleErrorFunction_const_u = typedef ::std::unique_ptr<const FixedAxisAngleErrorFunction>

Definition at line 447 of file fwd.h.

◆ FixedAxisAngleErrorFunction_const_w

using momentum::FixedAxisAngleErrorFunction_const_w = typedef ::std::weak_ptr<const FixedAxisAngleErrorFunction>

Definition at line 448 of file fwd.h.

◆ FixedAxisAngleErrorFunction_p

using momentum::FixedAxisAngleErrorFunction_p = typedef ::std::shared_ptr<FixedAxisAngleErrorFunction>

Definition at line 443 of file fwd.h.

◆ FixedAxisAngleErrorFunction_u

using momentum::FixedAxisAngleErrorFunction_u = typedef ::std::unique_ptr<FixedAxisAngleErrorFunction>

Definition at line 444 of file fwd.h.

◆ FixedAxisAngleErrorFunction_w

using momentum::FixedAxisAngleErrorFunction_w = typedef ::std::weak_ptr<FixedAxisAngleErrorFunction>

Definition at line 445 of file fwd.h.

◆ FixedAxisAngleErrorFunctiond

using momentum::FixedAxisAngleErrorFunctiond = typedef FixedAxisAngleErrorFunctionT<double>

Definition at line 441 of file fwd.h.

◆ FixedAxisAngleErrorFunctiond_const_p

using momentum::FixedAxisAngleErrorFunctiond_const_p = typedef ::std::shared_ptr<const FixedAxisAngleErrorFunctiond>

Definition at line 453 of file fwd.h.

◆ FixedAxisAngleErrorFunctiond_const_u

using momentum::FixedAxisAngleErrorFunctiond_const_u = typedef ::std::unique_ptr<const FixedAxisAngleErrorFunctiond>

Definition at line 454 of file fwd.h.

◆ FixedAxisAngleErrorFunctiond_const_w

using momentum::FixedAxisAngleErrorFunctiond_const_w = typedef ::std::weak_ptr<const FixedAxisAngleErrorFunctiond>

Definition at line 455 of file fwd.h.

◆ FixedAxisAngleErrorFunctiond_p

using momentum::FixedAxisAngleErrorFunctiond_p = typedef ::std::shared_ptr<FixedAxisAngleErrorFunctiond>

Definition at line 450 of file fwd.h.

◆ FixedAxisAngleErrorFunctiond_u

using momentum::FixedAxisAngleErrorFunctiond_u = typedef ::std::unique_ptr<FixedAxisAngleErrorFunctiond>

Definition at line 451 of file fwd.h.

◆ FixedAxisAngleErrorFunctiond_w

using momentum::FixedAxisAngleErrorFunctiond_w = typedef ::std::weak_ptr<FixedAxisAngleErrorFunctiond>

Definition at line 452 of file fwd.h.

◆ FixedAxisCosErrorFunction

using momentum::FixedAxisCosErrorFunction = typedef FixedAxisCosErrorFunctionT<float>

Definition at line 459 of file fwd.h.

◆ FixedAxisCosErrorFunction_const_p

using momentum::FixedAxisCosErrorFunction_const_p = typedef ::std::shared_ptr<const FixedAxisCosErrorFunction>

Definition at line 465 of file fwd.h.

◆ FixedAxisCosErrorFunction_const_u

using momentum::FixedAxisCosErrorFunction_const_u = typedef ::std::unique_ptr<const FixedAxisCosErrorFunction>

Definition at line 466 of file fwd.h.

◆ FixedAxisCosErrorFunction_const_w

using momentum::FixedAxisCosErrorFunction_const_w = typedef ::std::weak_ptr<const FixedAxisCosErrorFunction>

Definition at line 467 of file fwd.h.

◆ FixedAxisCosErrorFunction_p

using momentum::FixedAxisCosErrorFunction_p = typedef ::std::shared_ptr<FixedAxisCosErrorFunction>

Definition at line 462 of file fwd.h.

◆ FixedAxisCosErrorFunction_u

using momentum::FixedAxisCosErrorFunction_u = typedef ::std::unique_ptr<FixedAxisCosErrorFunction>

Definition at line 463 of file fwd.h.

◆ FixedAxisCosErrorFunction_w

using momentum::FixedAxisCosErrorFunction_w = typedef ::std::weak_ptr<FixedAxisCosErrorFunction>

Definition at line 464 of file fwd.h.

◆ FixedAxisCosErrorFunctiond

using momentum::FixedAxisCosErrorFunctiond = typedef FixedAxisCosErrorFunctionT<double>

Definition at line 460 of file fwd.h.

◆ FixedAxisCosErrorFunctiond_const_p

using momentum::FixedAxisCosErrorFunctiond_const_p = typedef ::std::shared_ptr<const FixedAxisCosErrorFunctiond>

Definition at line 472 of file fwd.h.

◆ FixedAxisCosErrorFunctiond_const_u

using momentum::FixedAxisCosErrorFunctiond_const_u = typedef ::std::unique_ptr<const FixedAxisCosErrorFunctiond>

Definition at line 473 of file fwd.h.

◆ FixedAxisCosErrorFunctiond_const_w

using momentum::FixedAxisCosErrorFunctiond_const_w = typedef ::std::weak_ptr<const FixedAxisCosErrorFunctiond>

Definition at line 474 of file fwd.h.

◆ FixedAxisCosErrorFunctiond_p

using momentum::FixedAxisCosErrorFunctiond_p = typedef ::std::shared_ptr<FixedAxisCosErrorFunctiond>

Definition at line 469 of file fwd.h.

◆ FixedAxisCosErrorFunctiond_u

using momentum::FixedAxisCosErrorFunctiond_u = typedef ::std::unique_ptr<FixedAxisCosErrorFunctiond>

Definition at line 470 of file fwd.h.

◆ FixedAxisCosErrorFunctiond_w

using momentum::FixedAxisCosErrorFunctiond_w = typedef ::std::weak_ptr<FixedAxisCosErrorFunctiond>

Definition at line 471 of file fwd.h.

◆ FixedAxisData

using momentum::FixedAxisData = typedef FixedAxisDataT<float>

Definition at line 84 of file fwd.h.

◆ FixedAxisData_const_p

using momentum::FixedAxisData_const_p = typedef ::std::shared_ptr<const FixedAxisData>

Definition at line 90 of file fwd.h.

◆ FixedAxisData_const_u

using momentum::FixedAxisData_const_u = typedef ::std::unique_ptr<const FixedAxisData>

Definition at line 91 of file fwd.h.

◆ FixedAxisData_const_w

using momentum::FixedAxisData_const_w = typedef ::std::weak_ptr<const FixedAxisData>

Definition at line 92 of file fwd.h.

◆ FixedAxisData_p

using momentum::FixedAxisData_p = typedef ::std::shared_ptr<FixedAxisData>

Definition at line 87 of file fwd.h.

◆ FixedAxisData_u

using momentum::FixedAxisData_u = typedef ::std::unique_ptr<FixedAxisData>

Definition at line 88 of file fwd.h.

◆ FixedAxisData_w

using momentum::FixedAxisData_w = typedef ::std::weak_ptr<FixedAxisData>

Definition at line 89 of file fwd.h.

◆ FixedAxisDatad

using momentum::FixedAxisDatad = typedef FixedAxisDataT<double>

Definition at line 85 of file fwd.h.

◆ FixedAxisDatad_const_p

using momentum::FixedAxisDatad_const_p = typedef ::std::shared_ptr<const FixedAxisDatad>

Definition at line 97 of file fwd.h.

◆ FixedAxisDatad_const_u

using momentum::FixedAxisDatad_const_u = typedef ::std::unique_ptr<const FixedAxisDatad>

Definition at line 98 of file fwd.h.

◆ FixedAxisDatad_const_w

using momentum::FixedAxisDatad_const_w = typedef ::std::weak_ptr<const FixedAxisDatad>

Definition at line 99 of file fwd.h.

◆ FixedAxisDatad_p

using momentum::FixedAxisDatad_p = typedef ::std::shared_ptr<FixedAxisDatad>

Definition at line 94 of file fwd.h.

◆ FixedAxisDatad_u

using momentum::FixedAxisDatad_u = typedef ::std::unique_ptr<FixedAxisDatad>

Definition at line 95 of file fwd.h.

◆ FixedAxisDatad_w

using momentum::FixedAxisDatad_w = typedef ::std::weak_ptr<FixedAxisDatad>

Definition at line 96 of file fwd.h.

◆ FixedAxisDiffErrorFunction

using momentum::FixedAxisDiffErrorFunction = typedef FixedAxisDiffErrorFunctionT<float>

Definition at line 478 of file fwd.h.

◆ FixedAxisDiffErrorFunction_const_p

using momentum::FixedAxisDiffErrorFunction_const_p = typedef ::std::shared_ptr<const FixedAxisDiffErrorFunction>

Definition at line 484 of file fwd.h.

◆ FixedAxisDiffErrorFunction_const_u

using momentum::FixedAxisDiffErrorFunction_const_u = typedef ::std::unique_ptr<const FixedAxisDiffErrorFunction>

Definition at line 485 of file fwd.h.

◆ FixedAxisDiffErrorFunction_const_w

using momentum::FixedAxisDiffErrorFunction_const_w = typedef ::std::weak_ptr<const FixedAxisDiffErrorFunction>

Definition at line 486 of file fwd.h.

◆ FixedAxisDiffErrorFunction_p

using momentum::FixedAxisDiffErrorFunction_p = typedef ::std::shared_ptr<FixedAxisDiffErrorFunction>

Definition at line 481 of file fwd.h.

◆ FixedAxisDiffErrorFunction_u

using momentum::FixedAxisDiffErrorFunction_u = typedef ::std::unique_ptr<FixedAxisDiffErrorFunction>

Definition at line 482 of file fwd.h.

◆ FixedAxisDiffErrorFunction_w

using momentum::FixedAxisDiffErrorFunction_w = typedef ::std::weak_ptr<FixedAxisDiffErrorFunction>

Definition at line 483 of file fwd.h.

◆ FixedAxisDiffErrorFunctiond

using momentum::FixedAxisDiffErrorFunctiond = typedef FixedAxisDiffErrorFunctionT<double>

Definition at line 479 of file fwd.h.

◆ FixedAxisDiffErrorFunctiond_const_p

using momentum::FixedAxisDiffErrorFunctiond_const_p = typedef ::std::shared_ptr<const FixedAxisDiffErrorFunctiond>

Definition at line 491 of file fwd.h.

◆ FixedAxisDiffErrorFunctiond_const_u

using momentum::FixedAxisDiffErrorFunctiond_const_u = typedef ::std::unique_ptr<const FixedAxisDiffErrorFunctiond>

Definition at line 492 of file fwd.h.

◆ FixedAxisDiffErrorFunctiond_const_w

using momentum::FixedAxisDiffErrorFunctiond_const_w = typedef ::std::weak_ptr<const FixedAxisDiffErrorFunctiond>

Definition at line 493 of file fwd.h.

◆ FixedAxisDiffErrorFunctiond_p

using momentum::FixedAxisDiffErrorFunctiond_p = typedef ::std::shared_ptr<FixedAxisDiffErrorFunctiond>

Definition at line 488 of file fwd.h.

◆ FixedAxisDiffErrorFunctiond_u

using momentum::FixedAxisDiffErrorFunctiond_u = typedef ::std::unique_ptr<FixedAxisDiffErrorFunctiond>

Definition at line 489 of file fwd.h.

◆ FixedAxisDiffErrorFunctiond_w

using momentum::FixedAxisDiffErrorFunctiond_w = typedef ::std::weak_ptr<FixedAxisDiffErrorFunctiond>

Definition at line 490 of file fwd.h.

◆ FloatP

using momentum::FloatP = typedef Packet<float>

Definition at line 40 of file simd.h.

◆ FullyDifferentiableDistanceErrorFunction

using momentum::FullyDifferentiableDistanceErrorFunction = typedef FullyDifferentiableDistanceErrorFunctionT<float>

Definition at line 115 of file fwd.h.

◆ FullyDifferentiableDistanceErrorFunction_const_p

using momentum::FullyDifferentiableDistanceErrorFunction_const_p = typedef ::std::shared_ptr<const FullyDifferentiableDistanceErrorFunction>

Definition at line 124 of file fwd.h.

◆ FullyDifferentiableDistanceErrorFunction_const_u

using momentum::FullyDifferentiableDistanceErrorFunction_const_u = typedef ::std::unique_ptr<const FullyDifferentiableDistanceErrorFunction>

Definition at line 126 of file fwd.h.

◆ FullyDifferentiableDistanceErrorFunction_const_w

using momentum::FullyDifferentiableDistanceErrorFunction_const_w = typedef ::std::weak_ptr<const FullyDifferentiableDistanceErrorFunction>

Definition at line 128 of file fwd.h.

◆ FullyDifferentiableDistanceErrorFunction_p

using momentum::FullyDifferentiableDistanceErrorFunction_p = typedef ::std::shared_ptr<FullyDifferentiableDistanceErrorFunction>

Definition at line 118 of file fwd.h.

◆ FullyDifferentiableDistanceErrorFunction_u

using momentum::FullyDifferentiableDistanceErrorFunction_u = typedef ::std::unique_ptr<FullyDifferentiableDistanceErrorFunction>

Definition at line 120 of file fwd.h.

◆ FullyDifferentiableDistanceErrorFunction_w

using momentum::FullyDifferentiableDistanceErrorFunction_w = typedef ::std::weak_ptr<FullyDifferentiableDistanceErrorFunction>

Definition at line 122 of file fwd.h.

◆ FullyDifferentiableDistanceErrorFunctiond

using momentum::FullyDifferentiableDistanceErrorFunctiond = typedef FullyDifferentiableDistanceErrorFunctionT<double>

Definition at line 116 of file fwd.h.

◆ FullyDifferentiableDistanceErrorFunctiond_const_p

using momentum::FullyDifferentiableDistanceErrorFunctiond_const_p = typedef ::std::shared_ptr<const FullyDifferentiableDistanceErrorFunctiond>

Definition at line 137 of file fwd.h.

◆ FullyDifferentiableDistanceErrorFunctiond_const_u

using momentum::FullyDifferentiableDistanceErrorFunctiond_const_u = typedef ::std::unique_ptr<const FullyDifferentiableDistanceErrorFunctiond>

Definition at line 139 of file fwd.h.

◆ FullyDifferentiableDistanceErrorFunctiond_const_w

using momentum::FullyDifferentiableDistanceErrorFunctiond_const_w = typedef ::std::weak_ptr<const FullyDifferentiableDistanceErrorFunctiond>

Definition at line 141 of file fwd.h.

◆ FullyDifferentiableDistanceErrorFunctiond_p

using momentum::FullyDifferentiableDistanceErrorFunctiond_p = typedef ::std::shared_ptr<FullyDifferentiableDistanceErrorFunctiond>

Definition at line 131 of file fwd.h.

◆ FullyDifferentiableDistanceErrorFunctiond_u

using momentum::FullyDifferentiableDistanceErrorFunctiond_u = typedef ::std::unique_ptr<FullyDifferentiableDistanceErrorFunctiond>

Definition at line 133 of file fwd.h.

◆ FullyDifferentiableDistanceErrorFunctiond_w

using momentum::FullyDifferentiableDistanceErrorFunctiond_w = typedef ::std::weak_ptr<FullyDifferentiableDistanceErrorFunctiond>

Definition at line 135 of file fwd.h.

◆ FullyDifferentiableMotionErrorFunction

using momentum::FullyDifferentiableMotionErrorFunction = typedef FullyDifferentiableMotionErrorFunctionT<float>

Definition at line 146 of file fwd.h.

◆ FullyDifferentiableMotionErrorFunction_const_p

using momentum::FullyDifferentiableMotionErrorFunction_const_p = typedef ::std::shared_ptr<const FullyDifferentiableMotionErrorFunction>

Definition at line 155 of file fwd.h.

◆ FullyDifferentiableMotionErrorFunction_const_u

using momentum::FullyDifferentiableMotionErrorFunction_const_u = typedef ::std::unique_ptr<const FullyDifferentiableMotionErrorFunction>

Definition at line 157 of file fwd.h.

◆ FullyDifferentiableMotionErrorFunction_const_w

using momentum::FullyDifferentiableMotionErrorFunction_const_w = typedef ::std::weak_ptr<const FullyDifferentiableMotionErrorFunction>

Definition at line 159 of file fwd.h.

◆ FullyDifferentiableMotionErrorFunction_p

using momentum::FullyDifferentiableMotionErrorFunction_p = typedef ::std::shared_ptr<FullyDifferentiableMotionErrorFunction>

Definition at line 149 of file fwd.h.

◆ FullyDifferentiableMotionErrorFunction_u

using momentum::FullyDifferentiableMotionErrorFunction_u = typedef ::std::unique_ptr<FullyDifferentiableMotionErrorFunction>

Definition at line 151 of file fwd.h.

◆ FullyDifferentiableMotionErrorFunction_w

using momentum::FullyDifferentiableMotionErrorFunction_w = typedef ::std::weak_ptr<FullyDifferentiableMotionErrorFunction>

Definition at line 153 of file fwd.h.

◆ FullyDifferentiableMotionErrorFunctiond

using momentum::FullyDifferentiableMotionErrorFunctiond = typedef FullyDifferentiableMotionErrorFunctionT<double>

Definition at line 147 of file fwd.h.

◆ FullyDifferentiableMotionErrorFunctiond_const_p

using momentum::FullyDifferentiableMotionErrorFunctiond_const_p = typedef ::std::shared_ptr<const FullyDifferentiableMotionErrorFunctiond>

Definition at line 168 of file fwd.h.

◆ FullyDifferentiableMotionErrorFunctiond_const_u

using momentum::FullyDifferentiableMotionErrorFunctiond_const_u = typedef ::std::unique_ptr<const FullyDifferentiableMotionErrorFunctiond>

Definition at line 170 of file fwd.h.

◆ FullyDifferentiableMotionErrorFunctiond_const_w

using momentum::FullyDifferentiableMotionErrorFunctiond_const_w = typedef ::std::weak_ptr<const FullyDifferentiableMotionErrorFunctiond>

Definition at line 172 of file fwd.h.

◆ FullyDifferentiableMotionErrorFunctiond_p

using momentum::FullyDifferentiableMotionErrorFunctiond_p = typedef ::std::shared_ptr<FullyDifferentiableMotionErrorFunctiond>

Definition at line 162 of file fwd.h.

◆ FullyDifferentiableMotionErrorFunctiond_u

using momentum::FullyDifferentiableMotionErrorFunctiond_u = typedef ::std::unique_ptr<FullyDifferentiableMotionErrorFunctiond>

Definition at line 164 of file fwd.h.

◆ FullyDifferentiableMotionErrorFunctiond_w

using momentum::FullyDifferentiableMotionErrorFunctiond_w = typedef ::std::weak_ptr<FullyDifferentiableMotionErrorFunctiond>

Definition at line 166 of file fwd.h.

◆ FullyDifferentiableOrientationErrorFunction

using momentum::FullyDifferentiableOrientationErrorFunction = typedef FullyDifferentiableOrientationErrorFunctionT<float>

Definition at line 177 of file fwd.h.

◆ FullyDifferentiableOrientationErrorFunction_const_p

using momentum::FullyDifferentiableOrientationErrorFunction_const_p = typedef ::std::shared_ptr<const FullyDifferentiableOrientationErrorFunction>

Definition at line 188 of file fwd.h.

◆ FullyDifferentiableOrientationErrorFunction_const_u

using momentum::FullyDifferentiableOrientationErrorFunction_const_u = typedef ::std::unique_ptr<const FullyDifferentiableOrientationErrorFunction>

Definition at line 190 of file fwd.h.

◆ FullyDifferentiableOrientationErrorFunction_const_w

using momentum::FullyDifferentiableOrientationErrorFunction_const_w = typedef ::std::weak_ptr<const FullyDifferentiableOrientationErrorFunction>

Definition at line 192 of file fwd.h.

◆ FullyDifferentiableOrientationErrorFunction_p

using momentum::FullyDifferentiableOrientationErrorFunction_p = typedef ::std::shared_ptr<FullyDifferentiableOrientationErrorFunction>

Definition at line 182 of file fwd.h.

◆ FullyDifferentiableOrientationErrorFunction_u

using momentum::FullyDifferentiableOrientationErrorFunction_u = typedef ::std::unique_ptr<FullyDifferentiableOrientationErrorFunction>

Definition at line 184 of file fwd.h.

◆ FullyDifferentiableOrientationErrorFunction_w

using momentum::FullyDifferentiableOrientationErrorFunction_w = typedef ::std::weak_ptr<FullyDifferentiableOrientationErrorFunction>

Definition at line 186 of file fwd.h.

◆ FullyDifferentiableOrientationErrorFunctiond

using momentum::FullyDifferentiableOrientationErrorFunctiond = typedef FullyDifferentiableOrientationErrorFunctionT<double>

Definition at line 179 of file fwd.h.

◆ FullyDifferentiableOrientationErrorFunctiond_const_p

using momentum::FullyDifferentiableOrientationErrorFunctiond_const_p = typedef ::std::shared_ptr<const FullyDifferentiableOrientationErrorFunctiond>

Definition at line 201 of file fwd.h.

◆ FullyDifferentiableOrientationErrorFunctiond_const_u

using momentum::FullyDifferentiableOrientationErrorFunctiond_const_u = typedef ::std::unique_ptr<const FullyDifferentiableOrientationErrorFunctiond>

Definition at line 203 of file fwd.h.

◆ FullyDifferentiableOrientationErrorFunctiond_const_w

using momentum::FullyDifferentiableOrientationErrorFunctiond_const_w = typedef ::std::weak_ptr<const FullyDifferentiableOrientationErrorFunctiond>

Definition at line 205 of file fwd.h.

◆ FullyDifferentiableOrientationErrorFunctiond_p

using momentum::FullyDifferentiableOrientationErrorFunctiond_p = typedef ::std::shared_ptr<FullyDifferentiableOrientationErrorFunctiond>

Definition at line 195 of file fwd.h.

◆ FullyDifferentiableOrientationErrorFunctiond_u

using momentum::FullyDifferentiableOrientationErrorFunctiond_u = typedef ::std::unique_ptr<FullyDifferentiableOrientationErrorFunctiond>

Definition at line 197 of file fwd.h.

◆ FullyDifferentiableOrientationErrorFunctiond_w

using momentum::FullyDifferentiableOrientationErrorFunctiond_w = typedef ::std::weak_ptr<FullyDifferentiableOrientationErrorFunctiond>

Definition at line 199 of file fwd.h.

◆ FullyDifferentiablePosePriorErrorFunction

using momentum::FullyDifferentiablePosePriorErrorFunction = typedef FullyDifferentiablePosePriorErrorFunctionT<float>

Definition at line 210 of file fwd.h.

◆ FullyDifferentiablePosePriorErrorFunction_const_p

using momentum::FullyDifferentiablePosePriorErrorFunction_const_p = typedef ::std::shared_ptr<const FullyDifferentiablePosePriorErrorFunction>

Definition at line 220 of file fwd.h.

◆ FullyDifferentiablePosePriorErrorFunction_const_u

using momentum::FullyDifferentiablePosePriorErrorFunction_const_u = typedef ::std::unique_ptr<const FullyDifferentiablePosePriorErrorFunction>

Definition at line 222 of file fwd.h.

◆ FullyDifferentiablePosePriorErrorFunction_const_w

using momentum::FullyDifferentiablePosePriorErrorFunction_const_w = typedef ::std::weak_ptr<const FullyDifferentiablePosePriorErrorFunction>

Definition at line 224 of file fwd.h.

◆ FullyDifferentiablePosePriorErrorFunction_p

using momentum::FullyDifferentiablePosePriorErrorFunction_p = typedef ::std::shared_ptr<FullyDifferentiablePosePriorErrorFunction>

Definition at line 214 of file fwd.h.

◆ FullyDifferentiablePosePriorErrorFunction_u

using momentum::FullyDifferentiablePosePriorErrorFunction_u = typedef ::std::unique_ptr<FullyDifferentiablePosePriorErrorFunction>

Definition at line 216 of file fwd.h.

◆ FullyDifferentiablePosePriorErrorFunction_w

using momentum::FullyDifferentiablePosePriorErrorFunction_w = typedef ::std::weak_ptr<FullyDifferentiablePosePriorErrorFunction>

Definition at line 218 of file fwd.h.

◆ FullyDifferentiablePosePriorErrorFunctiond

using momentum::FullyDifferentiablePosePriorErrorFunctiond = typedef FullyDifferentiablePosePriorErrorFunctionT<double>

Definition at line 211 of file fwd.h.

◆ FullyDifferentiablePosePriorErrorFunctiond_const_p

using momentum::FullyDifferentiablePosePriorErrorFunctiond_const_p = typedef ::std::shared_ptr<const FullyDifferentiablePosePriorErrorFunctiond>

Definition at line 233 of file fwd.h.

◆ FullyDifferentiablePosePriorErrorFunctiond_const_u

using momentum::FullyDifferentiablePosePriorErrorFunctiond_const_u = typedef ::std::unique_ptr<const FullyDifferentiablePosePriorErrorFunctiond>

Definition at line 235 of file fwd.h.

◆ FullyDifferentiablePosePriorErrorFunctiond_const_w

using momentum::FullyDifferentiablePosePriorErrorFunctiond_const_w = typedef ::std::weak_ptr<const FullyDifferentiablePosePriorErrorFunctiond>

Definition at line 237 of file fwd.h.

◆ FullyDifferentiablePosePriorErrorFunctiond_p

using momentum::FullyDifferentiablePosePriorErrorFunctiond_p = typedef ::std::shared_ptr<FullyDifferentiablePosePriorErrorFunctiond>

Definition at line 227 of file fwd.h.

◆ FullyDifferentiablePosePriorErrorFunctiond_u

using momentum::FullyDifferentiablePosePriorErrorFunctiond_u = typedef ::std::unique_ptr<FullyDifferentiablePosePriorErrorFunctiond>

Definition at line 229 of file fwd.h.

◆ FullyDifferentiablePosePriorErrorFunctiond_w

using momentum::FullyDifferentiablePosePriorErrorFunctiond_w = typedef ::std::weak_ptr<FullyDifferentiablePosePriorErrorFunctiond>

Definition at line 231 of file fwd.h.

◆ FullyDifferentiablePositionErrorFunction

using momentum::FullyDifferentiablePositionErrorFunction = typedef FullyDifferentiablePositionErrorFunctionT<float>

Definition at line 242 of file fwd.h.

◆ FullyDifferentiablePositionErrorFunction_const_p

using momentum::FullyDifferentiablePositionErrorFunction_const_p = typedef ::std::shared_ptr<const FullyDifferentiablePositionErrorFunction>

Definition at line 251 of file fwd.h.

◆ FullyDifferentiablePositionErrorFunction_const_u

using momentum::FullyDifferentiablePositionErrorFunction_const_u = typedef ::std::unique_ptr<const FullyDifferentiablePositionErrorFunction>

Definition at line 253 of file fwd.h.

◆ FullyDifferentiablePositionErrorFunction_const_w

using momentum::FullyDifferentiablePositionErrorFunction_const_w = typedef ::std::weak_ptr<const FullyDifferentiablePositionErrorFunction>

Definition at line 255 of file fwd.h.

◆ FullyDifferentiablePositionErrorFunction_p

using momentum::FullyDifferentiablePositionErrorFunction_p = typedef ::std::shared_ptr<FullyDifferentiablePositionErrorFunction>

Definition at line 245 of file fwd.h.

◆ FullyDifferentiablePositionErrorFunction_u

using momentum::FullyDifferentiablePositionErrorFunction_u = typedef ::std::unique_ptr<FullyDifferentiablePositionErrorFunction>

Definition at line 247 of file fwd.h.

◆ FullyDifferentiablePositionErrorFunction_w

using momentum::FullyDifferentiablePositionErrorFunction_w = typedef ::std::weak_ptr<FullyDifferentiablePositionErrorFunction>

Definition at line 249 of file fwd.h.

◆ FullyDifferentiablePositionErrorFunctiond

using momentum::FullyDifferentiablePositionErrorFunctiond = typedef FullyDifferentiablePositionErrorFunctionT<double>

Definition at line 243 of file fwd.h.

◆ FullyDifferentiablePositionErrorFunctiond_const_p

using momentum::FullyDifferentiablePositionErrorFunctiond_const_p = typedef ::std::shared_ptr<const FullyDifferentiablePositionErrorFunctiond>

Definition at line 264 of file fwd.h.

◆ FullyDifferentiablePositionErrorFunctiond_const_u

using momentum::FullyDifferentiablePositionErrorFunctiond_const_u = typedef ::std::unique_ptr<const FullyDifferentiablePositionErrorFunctiond>

Definition at line 266 of file fwd.h.

◆ FullyDifferentiablePositionErrorFunctiond_const_w

using momentum::FullyDifferentiablePositionErrorFunctiond_const_w = typedef ::std::weak_ptr<const FullyDifferentiablePositionErrorFunctiond>

Definition at line 268 of file fwd.h.

◆ FullyDifferentiablePositionErrorFunctiond_p

using momentum::FullyDifferentiablePositionErrorFunctiond_p = typedef ::std::shared_ptr<FullyDifferentiablePositionErrorFunctiond>

Definition at line 258 of file fwd.h.

◆ FullyDifferentiablePositionErrorFunctiond_u

using momentum::FullyDifferentiablePositionErrorFunctiond_u = typedef ::std::unique_ptr<FullyDifferentiablePositionErrorFunctiond>

Definition at line 260 of file fwd.h.

◆ FullyDifferentiablePositionErrorFunctiond_w

using momentum::FullyDifferentiablePositionErrorFunctiond_w = typedef ::std::weak_ptr<FullyDifferentiablePositionErrorFunctiond>

Definition at line 262 of file fwd.h.

◆ FullyDifferentiableProjectionErrorFunction

using momentum::FullyDifferentiableProjectionErrorFunction = typedef FullyDifferentiableProjectionErrorFunctionT<float>

Definition at line 273 of file fwd.h.

◆ FullyDifferentiableProjectionErrorFunction_const_p

using momentum::FullyDifferentiableProjectionErrorFunction_const_p = typedef ::std::shared_ptr<const FullyDifferentiableProjectionErrorFunction>

Definition at line 284 of file fwd.h.

◆ FullyDifferentiableProjectionErrorFunction_const_u

using momentum::FullyDifferentiableProjectionErrorFunction_const_u = typedef ::std::unique_ptr<const FullyDifferentiableProjectionErrorFunction>

Definition at line 286 of file fwd.h.

◆ FullyDifferentiableProjectionErrorFunction_const_w

using momentum::FullyDifferentiableProjectionErrorFunction_const_w = typedef ::std::weak_ptr<const FullyDifferentiableProjectionErrorFunction>

Definition at line 288 of file fwd.h.

◆ FullyDifferentiableProjectionErrorFunction_p

using momentum::FullyDifferentiableProjectionErrorFunction_p = typedef ::std::shared_ptr<FullyDifferentiableProjectionErrorFunction>

Definition at line 278 of file fwd.h.

◆ FullyDifferentiableProjectionErrorFunction_u

using momentum::FullyDifferentiableProjectionErrorFunction_u = typedef ::std::unique_ptr<FullyDifferentiableProjectionErrorFunction>

Definition at line 280 of file fwd.h.

◆ FullyDifferentiableProjectionErrorFunction_w

using momentum::FullyDifferentiableProjectionErrorFunction_w = typedef ::std::weak_ptr<FullyDifferentiableProjectionErrorFunction>

Definition at line 282 of file fwd.h.

◆ FullyDifferentiableProjectionErrorFunctiond

using momentum::FullyDifferentiableProjectionErrorFunctiond = typedef FullyDifferentiableProjectionErrorFunctionT<double>

Definition at line 275 of file fwd.h.

◆ FullyDifferentiableProjectionErrorFunctiond_const_p

using momentum::FullyDifferentiableProjectionErrorFunctiond_const_p = typedef ::std::shared_ptr<const FullyDifferentiableProjectionErrorFunctiond>

Definition at line 297 of file fwd.h.

◆ FullyDifferentiableProjectionErrorFunctiond_const_u

using momentum::FullyDifferentiableProjectionErrorFunctiond_const_u = typedef ::std::unique_ptr<const FullyDifferentiableProjectionErrorFunctiond>

Definition at line 299 of file fwd.h.

◆ FullyDifferentiableProjectionErrorFunctiond_const_w

using momentum::FullyDifferentiableProjectionErrorFunctiond_const_w = typedef ::std::weak_ptr<const FullyDifferentiableProjectionErrorFunctiond>

Definition at line 301 of file fwd.h.

◆ FullyDifferentiableProjectionErrorFunctiond_p

using momentum::FullyDifferentiableProjectionErrorFunctiond_p = typedef ::std::shared_ptr<FullyDifferentiableProjectionErrorFunctiond>

Definition at line 291 of file fwd.h.

◆ FullyDifferentiableProjectionErrorFunctiond_u

using momentum::FullyDifferentiableProjectionErrorFunctiond_u = typedef ::std::unique_ptr<FullyDifferentiableProjectionErrorFunctiond>

Definition at line 293 of file fwd.h.

◆ FullyDifferentiableProjectionErrorFunctiond_w

using momentum::FullyDifferentiableProjectionErrorFunctiond_w = typedef ::std::weak_ptr<FullyDifferentiableProjectionErrorFunctiond>

Definition at line 295 of file fwd.h.

◆ FullyDifferentiableSkeletonErrorFunction

using momentum::FullyDifferentiableSkeletonErrorFunction = typedef FullyDifferentiableSkeletonErrorFunctionT<float>

Definition at line 306 of file fwd.h.

◆ FullyDifferentiableSkeletonErrorFunction_const_p

using momentum::FullyDifferentiableSkeletonErrorFunction_const_p = typedef ::std::shared_ptr<const FullyDifferentiableSkeletonErrorFunction>

Definition at line 315 of file fwd.h.

◆ FullyDifferentiableSkeletonErrorFunction_const_u

using momentum::FullyDifferentiableSkeletonErrorFunction_const_u = typedef ::std::unique_ptr<const FullyDifferentiableSkeletonErrorFunction>

Definition at line 317 of file fwd.h.

◆ FullyDifferentiableSkeletonErrorFunction_const_w

using momentum::FullyDifferentiableSkeletonErrorFunction_const_w = typedef ::std::weak_ptr<const FullyDifferentiableSkeletonErrorFunction>

Definition at line 319 of file fwd.h.

◆ FullyDifferentiableSkeletonErrorFunction_p

using momentum::FullyDifferentiableSkeletonErrorFunction_p = typedef ::std::shared_ptr<FullyDifferentiableSkeletonErrorFunction>

Definition at line 309 of file fwd.h.

◆ FullyDifferentiableSkeletonErrorFunction_u

using momentum::FullyDifferentiableSkeletonErrorFunction_u = typedef ::std::unique_ptr<FullyDifferentiableSkeletonErrorFunction>

Definition at line 311 of file fwd.h.

◆ FullyDifferentiableSkeletonErrorFunction_w

using momentum::FullyDifferentiableSkeletonErrorFunction_w = typedef ::std::weak_ptr<FullyDifferentiableSkeletonErrorFunction>

Definition at line 313 of file fwd.h.

◆ FullyDifferentiableSkeletonErrorFunctiond

using momentum::FullyDifferentiableSkeletonErrorFunctiond = typedef FullyDifferentiableSkeletonErrorFunctionT<double>

Definition at line 307 of file fwd.h.

◆ FullyDifferentiableSkeletonErrorFunctiond_const_p

using momentum::FullyDifferentiableSkeletonErrorFunctiond_const_p = typedef ::std::shared_ptr<const FullyDifferentiableSkeletonErrorFunctiond>

Definition at line 328 of file fwd.h.

◆ FullyDifferentiableSkeletonErrorFunctiond_const_u

using momentum::FullyDifferentiableSkeletonErrorFunctiond_const_u = typedef ::std::unique_ptr<const FullyDifferentiableSkeletonErrorFunctiond>

Definition at line 330 of file fwd.h.

◆ FullyDifferentiableSkeletonErrorFunctiond_const_w

using momentum::FullyDifferentiableSkeletonErrorFunctiond_const_w = typedef ::std::weak_ptr<const FullyDifferentiableSkeletonErrorFunctiond>

Definition at line 332 of file fwd.h.

◆ FullyDifferentiableSkeletonErrorFunctiond_p

using momentum::FullyDifferentiableSkeletonErrorFunctiond_p = typedef ::std::shared_ptr<FullyDifferentiableSkeletonErrorFunctiond>

Definition at line 322 of file fwd.h.

◆ FullyDifferentiableSkeletonErrorFunctiond_u

using momentum::FullyDifferentiableSkeletonErrorFunctiond_u = typedef ::std::unique_ptr<FullyDifferentiableSkeletonErrorFunctiond>

Definition at line 324 of file fwd.h.

◆ FullyDifferentiableSkeletonErrorFunctiond_w

using momentum::FullyDifferentiableSkeletonErrorFunctiond_w = typedef ::std::weak_ptr<FullyDifferentiableSkeletonErrorFunctiond>

Definition at line 326 of file fwd.h.

◆ FullyDifferentiableStateErrorFunction

using momentum::FullyDifferentiableStateErrorFunction = typedef FullyDifferentiableStateErrorFunctionT<float>

Definition at line 337 of file fwd.h.

◆ FullyDifferentiableStateErrorFunction_const_p

using momentum::FullyDifferentiableStateErrorFunction_const_p = typedef ::std::shared_ptr<const FullyDifferentiableStateErrorFunction>

Definition at line 346 of file fwd.h.

◆ FullyDifferentiableStateErrorFunction_const_u

using momentum::FullyDifferentiableStateErrorFunction_const_u = typedef ::std::unique_ptr<const FullyDifferentiableStateErrorFunction>

Definition at line 348 of file fwd.h.

◆ FullyDifferentiableStateErrorFunction_const_w

using momentum::FullyDifferentiableStateErrorFunction_const_w = typedef ::std::weak_ptr<const FullyDifferentiableStateErrorFunction>

Definition at line 350 of file fwd.h.

◆ FullyDifferentiableStateErrorFunction_p

using momentum::FullyDifferentiableStateErrorFunction_p = typedef ::std::shared_ptr<FullyDifferentiableStateErrorFunction>

Definition at line 340 of file fwd.h.

◆ FullyDifferentiableStateErrorFunction_u

using momentum::FullyDifferentiableStateErrorFunction_u = typedef ::std::unique_ptr<FullyDifferentiableStateErrorFunction>

Definition at line 342 of file fwd.h.

◆ FullyDifferentiableStateErrorFunction_w

using momentum::FullyDifferentiableStateErrorFunction_w = typedef ::std::weak_ptr<FullyDifferentiableStateErrorFunction>

Definition at line 344 of file fwd.h.

◆ FullyDifferentiableStateErrorFunctiond

using momentum::FullyDifferentiableStateErrorFunctiond = typedef FullyDifferentiableStateErrorFunctionT<double>

Definition at line 338 of file fwd.h.

◆ FullyDifferentiableStateErrorFunctiond_const_p

using momentum::FullyDifferentiableStateErrorFunctiond_const_p = typedef ::std::shared_ptr<const FullyDifferentiableStateErrorFunctiond>

Definition at line 359 of file fwd.h.

◆ FullyDifferentiableStateErrorFunctiond_const_u

using momentum::FullyDifferentiableStateErrorFunctiond_const_u = typedef ::std::unique_ptr<const FullyDifferentiableStateErrorFunctiond>

Definition at line 361 of file fwd.h.

◆ FullyDifferentiableStateErrorFunctiond_const_w

using momentum::FullyDifferentiableStateErrorFunctiond_const_w = typedef ::std::weak_ptr<const FullyDifferentiableStateErrorFunctiond>

Definition at line 363 of file fwd.h.

◆ FullyDifferentiableStateErrorFunctiond_p

using momentum::FullyDifferentiableStateErrorFunctiond_p = typedef ::std::shared_ptr<FullyDifferentiableStateErrorFunctiond>

Definition at line 353 of file fwd.h.

◆ FullyDifferentiableStateErrorFunctiond_u

using momentum::FullyDifferentiableStateErrorFunctiond_u = typedef ::std::unique_ptr<FullyDifferentiableStateErrorFunctiond>

Definition at line 355 of file fwd.h.

◆ FullyDifferentiableStateErrorFunctiond_w

using momentum::FullyDifferentiableStateErrorFunctiond_w = typedef ::std::weak_ptr<FullyDifferentiableStateErrorFunctiond>

Definition at line 357 of file fwd.h.

◆ GaussNewtonSolver

using momentum::GaussNewtonSolver = typedef GaussNewtonSolverT<float>

Definition at line 76 of file fwd.h.

◆ GaussNewtonSolver_const_p

using momentum::GaussNewtonSolver_const_p = typedef ::std::shared_ptr<const GaussNewtonSolver>

Definition at line 82 of file fwd.h.

◆ GaussNewtonSolver_const_u

using momentum::GaussNewtonSolver_const_u = typedef ::std::unique_ptr<const GaussNewtonSolver>

Definition at line 83 of file fwd.h.

◆ GaussNewtonSolver_const_w

using momentum::GaussNewtonSolver_const_w = typedef ::std::weak_ptr<const GaussNewtonSolver>

Definition at line 84 of file fwd.h.

◆ GaussNewtonSolver_p

using momentum::GaussNewtonSolver_p = typedef ::std::shared_ptr<GaussNewtonSolver>

Definition at line 79 of file fwd.h.

◆ GaussNewtonSolver_u

using momentum::GaussNewtonSolver_u = typedef ::std::unique_ptr<GaussNewtonSolver>

Definition at line 80 of file fwd.h.

◆ GaussNewtonSolver_w

using momentum::GaussNewtonSolver_w = typedef ::std::weak_ptr<GaussNewtonSolver>

Definition at line 81 of file fwd.h.

◆ GaussNewtonSolverd

using momentum::GaussNewtonSolverd = typedef GaussNewtonSolverT<double>

Definition at line 77 of file fwd.h.

◆ GaussNewtonSolverd_const_p

using momentum::GaussNewtonSolverd_const_p = typedef ::std::shared_ptr<const GaussNewtonSolverd>

Definition at line 89 of file fwd.h.

◆ GaussNewtonSolverd_const_u

using momentum::GaussNewtonSolverd_const_u = typedef ::std::unique_ptr<const GaussNewtonSolverd>

Definition at line 90 of file fwd.h.

◆ GaussNewtonSolverd_const_w

using momentum::GaussNewtonSolverd_const_w = typedef ::std::weak_ptr<const GaussNewtonSolverd>

Definition at line 91 of file fwd.h.

◆ GaussNewtonSolverd_p

using momentum::GaussNewtonSolverd_p = typedef ::std::shared_ptr<GaussNewtonSolverd>

Definition at line 86 of file fwd.h.

◆ GaussNewtonSolverd_u

using momentum::GaussNewtonSolverd_u = typedef ::std::unique_ptr<GaussNewtonSolverd>

Definition at line 87 of file fwd.h.

◆ GaussNewtonSolverd_w

using momentum::GaussNewtonSolverd_w = typedef ::std::weak_ptr<GaussNewtonSolverd>

Definition at line 88 of file fwd.h.

◆ GaussNewtonSolverOptions_const_p

using momentum::GaussNewtonSolverOptions_const_p = typedef ::std::shared_ptr<const GaussNewtonSolverOptions>

Definition at line 32 of file fwd.h.

◆ GaussNewtonSolverOptions_const_u

using momentum::GaussNewtonSolverOptions_const_u = typedef ::std::unique_ptr<const GaussNewtonSolverOptions>

Definition at line 33 of file fwd.h.

◆ GaussNewtonSolverOptions_const_w

using momentum::GaussNewtonSolverOptions_const_w = typedef ::std::weak_ptr<const GaussNewtonSolverOptions>

Definition at line 34 of file fwd.h.

◆ GaussNewtonSolverOptions_p

using momentum::GaussNewtonSolverOptions_p = typedef ::std::shared_ptr<GaussNewtonSolverOptions>

Definition at line 29 of file fwd.h.

◆ GaussNewtonSolverOptions_u

using momentum::GaussNewtonSolverOptions_u = typedef ::std::unique_ptr<GaussNewtonSolverOptions>

Definition at line 30 of file fwd.h.

◆ GaussNewtonSolverOptions_w

using momentum::GaussNewtonSolverOptions_w = typedef ::std::weak_ptr<GaussNewtonSolverOptions>

Definition at line 31 of file fwd.h.

◆ GaussNewtonSolverQR

using momentum::GaussNewtonSolverQR = typedef GaussNewtonSolverQRT<float>

Definition at line 497 of file fwd.h.

◆ GaussNewtonSolverQR_const_p

using momentum::GaussNewtonSolverQR_const_p = typedef ::std::shared_ptr<const GaussNewtonSolverQR>

Definition at line 503 of file fwd.h.

◆ GaussNewtonSolverQR_const_u

using momentum::GaussNewtonSolverQR_const_u = typedef ::std::unique_ptr<const GaussNewtonSolverQR>

Definition at line 504 of file fwd.h.

◆ GaussNewtonSolverQR_const_w

using momentum::GaussNewtonSolverQR_const_w = typedef ::std::weak_ptr<const GaussNewtonSolverQR>

Definition at line 505 of file fwd.h.

◆ GaussNewtonSolverQR_p

using momentum::GaussNewtonSolverQR_p = typedef ::std::shared_ptr<GaussNewtonSolverQR>

Definition at line 500 of file fwd.h.

◆ GaussNewtonSolverQR_u

using momentum::GaussNewtonSolverQR_u = typedef ::std::unique_ptr<GaussNewtonSolverQR>

Definition at line 501 of file fwd.h.

◆ GaussNewtonSolverQR_w

using momentum::GaussNewtonSolverQR_w = typedef ::std::weak_ptr<GaussNewtonSolverQR>

Definition at line 502 of file fwd.h.

◆ GaussNewtonSolverQRd

using momentum::GaussNewtonSolverQRd = typedef GaussNewtonSolverQRT<double>

Definition at line 498 of file fwd.h.

◆ GaussNewtonSolverQRd_const_p

using momentum::GaussNewtonSolverQRd_const_p = typedef ::std::shared_ptr<const GaussNewtonSolverQRd>

Definition at line 510 of file fwd.h.

◆ GaussNewtonSolverQRd_const_u

using momentum::GaussNewtonSolverQRd_const_u = typedef ::std::unique_ptr<const GaussNewtonSolverQRd>

Definition at line 511 of file fwd.h.

◆ GaussNewtonSolverQRd_const_w

using momentum::GaussNewtonSolverQRd_const_w = typedef ::std::weak_ptr<const GaussNewtonSolverQRd>

Definition at line 512 of file fwd.h.

◆ GaussNewtonSolverQRd_p

using momentum::GaussNewtonSolverQRd_p = typedef ::std::shared_ptr<GaussNewtonSolverQRd>

Definition at line 507 of file fwd.h.

◆ GaussNewtonSolverQRd_u

using momentum::GaussNewtonSolverQRd_u = typedef ::std::unique_ptr<GaussNewtonSolverQRd>

Definition at line 508 of file fwd.h.

◆ GaussNewtonSolverQRd_w

using momentum::GaussNewtonSolverQRd_w = typedef ::std::weak_ptr<GaussNewtonSolverQRd>

Definition at line 509 of file fwd.h.

◆ GaussNewtonSolverQROptions_const_p

using momentum::GaussNewtonSolverQROptions_const_p = typedef ::std::shared_ptr<const GaussNewtonSolverQROptions>

Definition at line 32 of file fwd.h.

◆ GaussNewtonSolverQROptions_const_u

using momentum::GaussNewtonSolverQROptions_const_u = typedef ::std::unique_ptr<const GaussNewtonSolverQROptions>

Definition at line 33 of file fwd.h.

◆ GaussNewtonSolverQROptions_const_w

using momentum::GaussNewtonSolverQROptions_const_w = typedef ::std::weak_ptr<const GaussNewtonSolverQROptions>

Definition at line 34 of file fwd.h.

◆ GaussNewtonSolverQROptions_p

using momentum::GaussNewtonSolverQROptions_p = typedef ::std::shared_ptr<GaussNewtonSolverQROptions>

Definition at line 29 of file fwd.h.

◆ GaussNewtonSolverQROptions_u

using momentum::GaussNewtonSolverQROptions_u = typedef ::std::unique_ptr<GaussNewtonSolverQROptions>

Definition at line 30 of file fwd.h.

◆ GaussNewtonSolverQROptions_w

using momentum::GaussNewtonSolverQROptions_w = typedef ::std::weak_ptr<GaussNewtonSolverQROptions>

Definition at line 31 of file fwd.h.

◆ GeneralizedLoss

using momentum::GeneralizedLoss = typedef GeneralizedLossT<float>

Definition at line 96 of file fwd.h.

◆ GeneralizedLoss_const_p

using momentum::GeneralizedLoss_const_p = typedef ::std::shared_ptr<const GeneralizedLoss>

Definition at line 102 of file fwd.h.

◆ GeneralizedLoss_const_u

using momentum::GeneralizedLoss_const_u = typedef ::std::unique_ptr<const GeneralizedLoss>

Definition at line 103 of file fwd.h.

◆ GeneralizedLoss_const_w

using momentum::GeneralizedLoss_const_w = typedef ::std::weak_ptr<const GeneralizedLoss>

Definition at line 104 of file fwd.h.

◆ GeneralizedLoss_p

using momentum::GeneralizedLoss_p = typedef ::std::shared_ptr<GeneralizedLoss>

Definition at line 99 of file fwd.h.

◆ GeneralizedLoss_u

using momentum::GeneralizedLoss_u = typedef ::std::unique_ptr<GeneralizedLoss>

Definition at line 100 of file fwd.h.

◆ GeneralizedLoss_w

using momentum::GeneralizedLoss_w = typedef ::std::weak_ptr<GeneralizedLoss>

Definition at line 101 of file fwd.h.

◆ GeneralizedLossd

using momentum::GeneralizedLossd = typedef GeneralizedLossT<double>

Definition at line 97 of file fwd.h.

◆ GeneralizedLossd_const_p

using momentum::GeneralizedLossd_const_p = typedef ::std::shared_ptr<const GeneralizedLossd>

Definition at line 109 of file fwd.h.

◆ GeneralizedLossd_const_u

using momentum::GeneralizedLossd_const_u = typedef ::std::unique_ptr<const GeneralizedLossd>

Definition at line 110 of file fwd.h.

◆ GeneralizedLossd_const_w

using momentum::GeneralizedLossd_const_w = typedef ::std::weak_ptr<const GeneralizedLossd>

Definition at line 111 of file fwd.h.

◆ GeneralizedLossd_p

using momentum::GeneralizedLossd_p = typedef ::std::shared_ptr<GeneralizedLossd>

Definition at line 106 of file fwd.h.

◆ GeneralizedLossd_u

using momentum::GeneralizedLossd_u = typedef ::std::unique_ptr<GeneralizedLossd>

Definition at line 107 of file fwd.h.

◆ GeneralizedLossd_w

using momentum::GeneralizedLossd_w = typedef ::std::weak_ptr<GeneralizedLossd>

Definition at line 108 of file fwd.h.

◆ GradientDescentSolver

using momentum::GradientDescentSolver = typedef GradientDescentSolverT<float>

Definition at line 95 of file fwd.h.

◆ GradientDescentSolver_const_p

using momentum::GradientDescentSolver_const_p = typedef ::std::shared_ptr<const GradientDescentSolver>

Definition at line 101 of file fwd.h.

◆ GradientDescentSolver_const_u

using momentum::GradientDescentSolver_const_u = typedef ::std::unique_ptr<const GradientDescentSolver>

Definition at line 102 of file fwd.h.

◆ GradientDescentSolver_const_w

using momentum::GradientDescentSolver_const_w = typedef ::std::weak_ptr<const GradientDescentSolver>

Definition at line 103 of file fwd.h.

◆ GradientDescentSolver_p

using momentum::GradientDescentSolver_p = typedef ::std::shared_ptr<GradientDescentSolver>

Definition at line 98 of file fwd.h.

◆ GradientDescentSolver_u

using momentum::GradientDescentSolver_u = typedef ::std::unique_ptr<GradientDescentSolver>

Definition at line 99 of file fwd.h.

◆ GradientDescentSolver_w

using momentum::GradientDescentSolver_w = typedef ::std::weak_ptr<GradientDescentSolver>

Definition at line 100 of file fwd.h.

◆ GradientDescentSolverd

using momentum::GradientDescentSolverd = typedef GradientDescentSolverT<double>

Definition at line 96 of file fwd.h.

◆ GradientDescentSolverd_const_p

using momentum::GradientDescentSolverd_const_p = typedef ::std::shared_ptr<const GradientDescentSolverd>

Definition at line 108 of file fwd.h.

◆ GradientDescentSolverd_const_u

using momentum::GradientDescentSolverd_const_u = typedef ::std::unique_ptr<const GradientDescentSolverd>

Definition at line 109 of file fwd.h.

◆ GradientDescentSolverd_const_w

using momentum::GradientDescentSolverd_const_w = typedef ::std::weak_ptr<const GradientDescentSolverd>

Definition at line 110 of file fwd.h.

◆ GradientDescentSolverd_p

using momentum::GradientDescentSolverd_p = typedef ::std::shared_ptr<GradientDescentSolverd>

Definition at line 105 of file fwd.h.

◆ GradientDescentSolverd_u

using momentum::GradientDescentSolverd_u = typedef ::std::unique_ptr<GradientDescentSolverd>

Definition at line 106 of file fwd.h.

◆ GradientDescentSolverd_w

using momentum::GradientDescentSolverd_w = typedef ::std::weak_ptr<GradientDescentSolverd>

Definition at line 107 of file fwd.h.

◆ HeightErrorFunction

using momentum::HeightErrorFunction = typedef HeightErrorFunctionT<float>

Definition at line 516 of file fwd.h.

◆ HeightErrorFunction_const_p

using momentum::HeightErrorFunction_const_p = typedef ::std::shared_ptr<const HeightErrorFunction>

Definition at line 522 of file fwd.h.

◆ HeightErrorFunction_const_u

using momentum::HeightErrorFunction_const_u = typedef ::std::unique_ptr<const HeightErrorFunction>

Definition at line 523 of file fwd.h.

◆ HeightErrorFunction_const_w

using momentum::HeightErrorFunction_const_w = typedef ::std::weak_ptr<const HeightErrorFunction>

Definition at line 524 of file fwd.h.

◆ HeightErrorFunction_p

using momentum::HeightErrorFunction_p = typedef ::std::shared_ptr<HeightErrorFunction>

Definition at line 519 of file fwd.h.

◆ HeightErrorFunction_u

using momentum::HeightErrorFunction_u = typedef ::std::unique_ptr<HeightErrorFunction>

Definition at line 520 of file fwd.h.

◆ HeightErrorFunction_w

using momentum::HeightErrorFunction_w = typedef ::std::weak_ptr<HeightErrorFunction>

Definition at line 521 of file fwd.h.

◆ HeightErrorFunctiond

using momentum::HeightErrorFunctiond = typedef HeightErrorFunctionT<double>

Definition at line 517 of file fwd.h.

◆ HeightErrorFunctiond_const_p

using momentum::HeightErrorFunctiond_const_p = typedef ::std::shared_ptr<const HeightErrorFunctiond>

Definition at line 529 of file fwd.h.

◆ HeightErrorFunctiond_const_u

using momentum::HeightErrorFunctiond_const_u = typedef ::std::unique_ptr<const HeightErrorFunctiond>

Definition at line 530 of file fwd.h.

◆ HeightErrorFunctiond_const_w

using momentum::HeightErrorFunctiond_const_w = typedef ::std::weak_ptr<const HeightErrorFunctiond>

Definition at line 531 of file fwd.h.

◆ HeightErrorFunctiond_p

using momentum::HeightErrorFunctiond_p = typedef ::std::shared_ptr<HeightErrorFunctiond>

Definition at line 526 of file fwd.h.

◆ HeightErrorFunctiond_u

using momentum::HeightErrorFunctiond_u = typedef ::std::unique_ptr<HeightErrorFunctiond>

Definition at line 527 of file fwd.h.

◆ HeightErrorFunctiond_w

using momentum::HeightErrorFunctiond_w = typedef ::std::weak_ptr<HeightErrorFunctiond>

Definition at line 528 of file fwd.h.

◆ IdentityParameters

typedef std::tuple< std::vector< std::string >, VectorXf > momentum::IdentityParameters

Definition at line 197 of file types.h.

◆ IndexMatrix

using momentum::IndexMatrix = typedef Eigen::Matrix<uint32_t, Eigen::Dynamic, kMaxSkinJoints, Eigen::AutoAlign | Eigen::RowMajor>

Matrix type for storing joint indices that influence each vertex.

Each row represents a vertex, and each column represents a joint influence. The matrix has a fixed number of columns (kMaxSkinJoints) and a dynamic number of rows.

Definition at line 25 of file skin_weights.h.

◆ IntP

using momentum::IntP = typedef Packet<int>

Definition at line 42 of file simd.h.

◆ InverseParameterTransform

using momentum::InverseParameterTransform = typedef InverseParameterTransformT<float>

Definition at line 55 of file inverse_parameter_transform.h.

◆ InverseParameterTransformd

using momentum::InverseParameterTransformd = typedef InverseParameterTransformT<double>

Definition at line 56 of file inverse_parameter_transform.h.

◆ Isometry3

template<typename T >

using momentum::Isometry3 = typedef Eigen::Transform<T, 3, Eigen::Isometry>

Definition at line 381 of file types.h.

◆ Isometry3d

using momentum::Isometry3d = typedef Isometry3<double>

Definition at line 383 of file types.h.

◆ Isometry3f

using momentum::Isometry3f = typedef Isometry3<float>

Definition at line 382 of file types.h.

◆ Joint

using momentum::Joint = typedef JointT<float>

Definition at line 131 of file fwd.h.

◆ Joint_const_p

using momentum::Joint_const_p = typedef ::std::shared_ptr<const Joint>

Definition at line 137 of file fwd.h.

◆ Joint_const_u

using momentum::Joint_const_u = typedef ::std::unique_ptr<const Joint>

Definition at line 138 of file fwd.h.

◆ Joint_const_w

using momentum::Joint_const_w = typedef ::std::weak_ptr<const Joint>

Definition at line 139 of file fwd.h.

◆ Joint_p

using momentum::Joint_p = typedef ::std::shared_ptr<Joint>

Definition at line 134 of file fwd.h.

◆ Joint_u

using momentum::Joint_u = typedef ::std::unique_ptr<Joint>

Definition at line 135 of file fwd.h.

◆ Joint_w

using momentum::Joint_w = typedef ::std::weak_ptr<Joint>

Definition at line 136 of file fwd.h.

◆ Jointd

using momentum::Jointd = typedef JointT<double>

Definition at line 132 of file fwd.h.

◆ Jointd_const_p

using momentum::Jointd_const_p = typedef ::std::shared_ptr<const Jointd>

Definition at line 144 of file fwd.h.

◆ Jointd_const_u

using momentum::Jointd_const_u = typedef ::std::unique_ptr<const Jointd>

Definition at line 145 of file fwd.h.

◆ Jointd_const_w

using momentum::Jointd_const_w = typedef ::std::weak_ptr<const Jointd>

Definition at line 146 of file fwd.h.

◆ Jointd_p

using momentum::Jointd_p = typedef ::std::shared_ptr<Jointd>

Definition at line 141 of file fwd.h.

◆ Jointd_u

using momentum::Jointd_u = typedef ::std::unique_ptr<Jointd>

Definition at line 142 of file fwd.h.

◆ Jointd_w

using momentum::Jointd_w = typedef ::std::weak_ptr<Jointd>

Definition at line 143 of file fwd.h.

◆ JointList

using momentum::JointList = typedef JointListT<float>

Definition at line 79 of file joint.h.

◆ JointListd

using momentum::JointListd = typedef JointListT<double>

Definition at line 80 of file joint.h.

◆ JointListT

template<typename T >

using momentum::JointListT = typedef std::vector<JointT<T> >

A list of joints (e.g., of a skeleton).

Definition at line 78 of file joint.h.

◆ JointParameters

using momentum::JointParameters = typedef JointParametersT<float>

Definition at line 150 of file types.h.

◆ JointParametersd

using momentum::JointParametersd = typedef JointParametersT<double>

Definition at line 151 of file types.h.

◆ JointState

typedef JointStateT< float > momentum::JointState

Definition at line 150 of file fwd.h.

◆ JointState_const_p

using momentum::JointState_const_p = typedef ::std::shared_ptr<const JointState>

Definition at line 156 of file fwd.h.

◆ JointState_const_u

using momentum::JointState_const_u = typedef ::std::unique_ptr<const JointState>

Definition at line 157 of file fwd.h.

◆ JointState_const_w

using momentum::JointState_const_w = typedef ::std::weak_ptr<const JointState>

Definition at line 158 of file fwd.h.

◆ JointState_p

using momentum::JointState_p = typedef ::std::shared_ptr<JointState>

Definition at line 153 of file fwd.h.

◆ JointState_u

using momentum::JointState_u = typedef ::std::unique_ptr<JointState>

Definition at line 154 of file fwd.h.

◆ JointState_w

using momentum::JointState_w = typedef ::std::weak_ptr<JointState>

Definition at line 155 of file fwd.h.

◆ JointStated

using momentum::JointStated = typedef JointStateT<double>

Definition at line 151 of file fwd.h.

◆ JointStated_const_p

using momentum::JointStated_const_p = typedef ::std::shared_ptr<const JointStated>

Definition at line 163 of file fwd.h.

◆ JointStated_const_u

using momentum::JointStated_const_u = typedef ::std::unique_ptr<const JointStated>

Definition at line 164 of file fwd.h.

◆ JointStated_const_w

using momentum::JointStated_const_w = typedef ::std::weak_ptr<const JointStated>

Definition at line 165 of file fwd.h.

◆ JointStated_p

using momentum::JointStated_p = typedef ::std::shared_ptr<JointStated>

Definition at line 160 of file fwd.h.

◆ JointStated_u

using momentum::JointStated_u = typedef ::std::unique_ptr<JointStated>

Definition at line 161 of file fwd.h.

◆ JointStated_w

using momentum::JointStated_w = typedef ::std::weak_ptr<JointStated>

Definition at line 162 of file fwd.h.

◆ JointStateList

typedef JointStateListT< float > momentum::JointStateList

Definition at line 239 of file joint_state.h.

◆ JointStateListd

using momentum::JointStateListd = typedef JointStateListT<double>

Definition at line 164 of file types.h.

◆ JointStateListT

template<typename T >

using momentum::JointStateListT = typedef std::vector<JointStateT<T> >

Structure describing the state of all joints in a skeleton.

Definition at line 236 of file joint_state.h.

◆ JointVector

using momentum::JointVector = typedef JointVectorT<float>

Definition at line 32 of file types.h.

◆ JointVectorT

template<typename T >

using momentum::JointVectorT = typedef Eigen::Matrix<T, kParametersPerJoint, 1>

Definition at line 31 of file types.h.

◆ LimitErrorFunction

using momentum::LimitErrorFunction = typedef LimitErrorFunctionT<float>

Definition at line 535 of file fwd.h.

◆ LimitErrorFunction_const_p

using momentum::LimitErrorFunction_const_p = typedef ::std::shared_ptr<const LimitErrorFunction>

Definition at line 541 of file fwd.h.

◆ LimitErrorFunction_const_u

using momentum::LimitErrorFunction_const_u = typedef ::std::unique_ptr<const LimitErrorFunction>

Definition at line 542 of file fwd.h.

◆ LimitErrorFunction_const_w

using momentum::LimitErrorFunction_const_w = typedef ::std::weak_ptr<const LimitErrorFunction>

Definition at line 543 of file fwd.h.

◆ LimitErrorFunction_p

using momentum::LimitErrorFunction_p = typedef ::std::shared_ptr<LimitErrorFunction>

Definition at line 538 of file fwd.h.

◆ LimitErrorFunction_u

using momentum::LimitErrorFunction_u = typedef ::std::unique_ptr<LimitErrorFunction>

Definition at line 539 of file fwd.h.

◆ LimitErrorFunction_w

using momentum::LimitErrorFunction_w = typedef ::std::weak_ptr<LimitErrorFunction>

Definition at line 540 of file fwd.h.

◆ LimitErrorFunctiond

using momentum::LimitErrorFunctiond = typedef LimitErrorFunctionT<double>

Definition at line 536 of file fwd.h.

◆ LimitErrorFunctiond_const_p

using momentum::LimitErrorFunctiond_const_p = typedef ::std::shared_ptr<const LimitErrorFunctiond>

Definition at line 548 of file fwd.h.

◆ LimitErrorFunctiond_const_u

using momentum::LimitErrorFunctiond_const_u = typedef ::std::unique_ptr<const LimitErrorFunctiond>

Definition at line 549 of file fwd.h.

◆ LimitErrorFunctiond_const_w

using momentum::LimitErrorFunctiond_const_w = typedef ::std::weak_ptr<const LimitErrorFunctiond>

Definition at line 550 of file fwd.h.

◆ LimitErrorFunctiond_p

using momentum::LimitErrorFunctiond_p = typedef ::std::shared_ptr<LimitErrorFunctiond>

Definition at line 545 of file fwd.h.

◆ LimitErrorFunctiond_u

using momentum::LimitErrorFunctiond_u = typedef ::std::unique_ptr<LimitErrorFunctiond>

Definition at line 546 of file fwd.h.

◆ LimitErrorFunctiond_w

using momentum::LimitErrorFunctiond_w = typedef ::std::weak_ptr<LimitErrorFunctiond>

Definition at line 547 of file fwd.h.

◆ Line

template<typename Scalar , int Dim>

using momentum::Line = typedef Eigen::ParametrizedLine<Scalar, Dim>

Definition at line 50 of file types.h.

◆ Locator_const_p

using momentum::Locator_const_p = typedef ::std::shared_ptr<const Locator>

Definition at line 41 of file fwd.h.

◆ Locator_const_u

using momentum::Locator_const_u = typedef ::std::unique_ptr<const Locator>

Definition at line 42 of file fwd.h.

◆ Locator_const_w

using momentum::Locator_const_w = typedef ::std::weak_ptr<const Locator>

Definition at line 43 of file fwd.h.

◆ Locator_p

using momentum::Locator_p = typedef ::std::shared_ptr<Locator>

Definition at line 38 of file fwd.h.

◆ Locator_u

using momentum::Locator_u = typedef ::std::unique_ptr<Locator>

Definition at line 39 of file fwd.h.

◆ Locator_w

using momentum::Locator_w = typedef ::std::weak_ptr<Locator>

Definition at line 40 of file fwd.h.

◆ LocatorList

using momentum::LocatorList = typedef std::vector<Locator>

A collection of locators attached to a skeleton.

Definition at line 92 of file locator.h.

◆ LowRankCovarianceMatrix

using momentum::LowRankCovarianceMatrix = typedef LowRankCovarianceMatrixT<float>

Definition at line 77 of file fwd.h.

◆ LowRankCovarianceMatrix_const_p

using momentum::LowRankCovarianceMatrix_const_p = typedef ::std::shared_ptr<const LowRankCovarianceMatrix>

Definition at line 83 of file fwd.h.

◆ LowRankCovarianceMatrix_const_u

using momentum::LowRankCovarianceMatrix_const_u = typedef ::std::unique_ptr<const LowRankCovarianceMatrix>

Definition at line 84 of file fwd.h.

◆ LowRankCovarianceMatrix_const_w

using momentum::LowRankCovarianceMatrix_const_w = typedef ::std::weak_ptr<const LowRankCovarianceMatrix>

Definition at line 85 of file fwd.h.

◆ LowRankCovarianceMatrix_p

using momentum::LowRankCovarianceMatrix_p = typedef ::std::shared_ptr<LowRankCovarianceMatrix>

Definition at line 80 of file fwd.h.

◆ LowRankCovarianceMatrix_u

using momentum::LowRankCovarianceMatrix_u = typedef ::std::unique_ptr<LowRankCovarianceMatrix>

Definition at line 81 of file fwd.h.

◆ LowRankCovarianceMatrix_w

using momentum::LowRankCovarianceMatrix_w = typedef ::std::weak_ptr<LowRankCovarianceMatrix>

Definition at line 82 of file fwd.h.

◆ LowRankCovarianceMatrixd

using momentum::LowRankCovarianceMatrixd = typedef LowRankCovarianceMatrixT<double>

Definition at line 78 of file fwd.h.

◆ LowRankCovarianceMatrixd_const_p

using momentum::LowRankCovarianceMatrixd_const_p = typedef ::std::shared_ptr<const LowRankCovarianceMatrixd>

Definition at line 90 of file fwd.h.

◆ LowRankCovarianceMatrixd_const_u

using momentum::LowRankCovarianceMatrixd_const_u = typedef ::std::unique_ptr<const LowRankCovarianceMatrixd>

Definition at line 91 of file fwd.h.

◆ LowRankCovarianceMatrixd_const_w

using momentum::LowRankCovarianceMatrixd_const_w = typedef ::std::weak_ptr<const LowRankCovarianceMatrixd>

Definition at line 92 of file fwd.h.

◆ LowRankCovarianceMatrixd_p

using momentum::LowRankCovarianceMatrixd_p = typedef ::std::shared_ptr<LowRankCovarianceMatrixd>

Definition at line 87 of file fwd.h.

◆ LowRankCovarianceMatrixd_u

using momentum::LowRankCovarianceMatrixd_u = typedef ::std::unique_ptr<LowRankCovarianceMatrixd>

Definition at line 88 of file fwd.h.

◆ LowRankCovarianceMatrixd_w

using momentum::LowRankCovarianceMatrixd_w = typedef ::std::weak_ptr<LowRankCovarianceMatrixd>

Definition at line 89 of file fwd.h.

◆ Map

template<class T >

using momentum::Map = typedef Eigen::Map<T>

Definition at line 44 of file types.h.

◆ Matrix0

template<typename T >

using momentum::Matrix0 = typedef Eigen::Matrix<T, 0, 0>

Definition at line 92 of file types.h.

◆ Matrix0b

using momentum::Matrix0b = typedef Matrix0<std::uint8_t>

Definition at line 122 of file types.h.

◆ Matrix0d

using momentum::Matrix0d = typedef Matrix0<double>

Definition at line 114 of file types.h.

◆ Matrix0f

using momentum::Matrix0f = typedef Matrix0<float>

Definition at line 106 of file types.h.

◆ Matrix0i

using momentum::Matrix0i = typedef Matrix0<std::int32_t>

Definition at line 146 of file types.h.

◆ Matrix0s

using momentum::Matrix0s = typedef Matrix0<std::uint16_t>

Definition at line 130 of file types.h.

◆ Matrix0u

using momentum::Matrix0u = typedef Matrix0<std::uint32_t>

Definition at line 138 of file types.h.

◆ Matrix1

template<typename T >

using momentum::Matrix1 = typedef Eigen::Matrix<T, 1, 1>

Definition at line 94 of file types.h.

◆ Matrix1b

using momentum::Matrix1b = typedef Matrix1<std::uint8_t>

Definition at line 123 of file types.h.

◆ Matrix1d

using momentum::Matrix1d = typedef Matrix1<double>

Definition at line 115 of file types.h.

◆ Matrix1f

using momentum::Matrix1f = typedef Matrix1<float>

Definition at line 107 of file types.h.

◆ Matrix1i

using momentum::Matrix1i = typedef Matrix1<std::int32_t>

Definition at line 147 of file types.h.

◆ Matrix1s

using momentum::Matrix1s = typedef Matrix1<std::uint16_t>

Definition at line 131 of file types.h.

◆ Matrix1u

using momentum::Matrix1u = typedef Matrix1<std::uint32_t>

Definition at line 139 of file types.h.

◆ Matrix2

template<typename T >

using momentum::Matrix2 = typedef Eigen::Matrix<T, 2, 2>

Definition at line 96 of file types.h.

◆ Matrix2b

using momentum::Matrix2b = typedef Matrix2<std::uint8_t>

Definition at line 124 of file types.h.

◆ Matrix2d

using momentum::Matrix2d = typedef Matrix2<double>

Definition at line 116 of file types.h.

◆ Matrix2f

using momentum::Matrix2f = typedef Matrix2<float>

Definition at line 108 of file types.h.

◆ Matrix2i

using momentum::Matrix2i = typedef Matrix2<std::int32_t>

Definition at line 148 of file types.h.

◆ Matrix2s

using momentum::Matrix2s = typedef Matrix2<std::uint16_t>

Definition at line 132 of file types.h.

◆ Matrix2u

using momentum::Matrix2u = typedef Matrix2<std::uint32_t>

Definition at line 140 of file types.h.

◆ Matrix3

template<typename T >

using momentum::Matrix3 = typedef Eigen::Matrix<T, 3, 3>

Definition at line 98 of file types.h.

◆ Matrix3b

using momentum::Matrix3b = typedef Matrix3<std::uint8_t>

Definition at line 125 of file types.h.

◆ Matrix3d

using momentum::Matrix3d = typedef Matrix3<double>

Definition at line 117 of file types.h.

◆ Matrix3f

using momentum::Matrix3f = typedef Matrix3<float>

Definition at line 109 of file types.h.

◆ Matrix3i

using momentum::Matrix3i = typedef Matrix3<std::int32_t>

Definition at line 149 of file types.h.

◆ Matrix3s

using momentum::Matrix3s = typedef Matrix3<std::uint16_t>

Definition at line 133 of file types.h.

◆ Matrix3u

using momentum::Matrix3u = typedef Matrix3<std::uint32_t>

Definition at line 141 of file types.h.

◆ Matrix3X

template<typename T >

using momentum::Matrix3X = typedef Eigen::Matrix<T, 3, Dynamic>

Definition at line 155 of file types.h.

◆ Matrix3Xb

using momentum::Matrix3Xb = typedef Matrix3X<std::uint8_t>

Definition at line 158 of file types.h.

◆ Matrix3Xd

using momentum::Matrix3Xd = typedef Matrix3X<double>

Definition at line 157 of file types.h.

◆ Matrix3Xf

using momentum::Matrix3Xf = typedef Matrix3X<float>

Definition at line 156 of file types.h.

◆ Matrix3Xi

using momentum::Matrix3Xi = typedef Matrix3X<std::int32_t>

Definition at line 161 of file types.h.

◆ Matrix3Xs

using momentum::Matrix3Xs = typedef Matrix3X<std::uint16_t>

Definition at line 159 of file types.h.

◆ Matrix3Xu

using momentum::Matrix3Xu = typedef Matrix3X<std::uint32_t>

Definition at line 160 of file types.h.

◆ Matrix4

template<typename T >

using momentum::Matrix4 = typedef Eigen::Matrix<T, 4, 4>

Definition at line 100 of file types.h.

◆ Matrix4b

using momentum::Matrix4b = typedef Matrix4<std::uint8_t>

Definition at line 126 of file types.h.

◆ Matrix4d

using momentum::Matrix4d = typedef Matrix4<double>

Definition at line 118 of file types.h.

◆ Matrix4f

using momentum::Matrix4f = typedef Matrix4<float>

Definition at line 110 of file types.h.

◆ Matrix4i

using momentum::Matrix4i = typedef Matrix4<std::int32_t>

Definition at line 150 of file types.h.

◆ Matrix4s

using momentum::Matrix4s = typedef Matrix4<std::uint16_t>

Definition at line 134 of file types.h.

◆ Matrix4u

using momentum::Matrix4u = typedef Matrix4<std::uint32_t>

Definition at line 142 of file types.h.

◆ Matrix5

template<typename T >

using momentum::Matrix5 = typedef Eigen::Matrix<T, 5, 5>

Definition at line 102 of file types.h.

◆ Matrix5b

using momentum::Matrix5b = typedef Matrix5<std::uint8_t>

Definition at line 127 of file types.h.

◆ Matrix5d

using momentum::Matrix5d = typedef Matrix5<double>

Definition at line 119 of file types.h.

◆ Matrix5f

using momentum::Matrix5f = typedef Matrix5<float>

Definition at line 111 of file types.h.

◆ Matrix5i

using momentum::Matrix5i = typedef Matrix5<std::int32_t>

Definition at line 151 of file types.h.

◆ Matrix5s

using momentum::Matrix5s = typedef Matrix5<std::uint16_t>

Definition at line 135 of file types.h.

◆ Matrix5u

using momentum::Matrix5u = typedef Matrix5<std::uint32_t>

Definition at line 143 of file types.h.

◆ Matrix6

template<typename T >

using momentum::Matrix6 = typedef Eigen::Matrix<T, 6, 6>

Definition at line 104 of file types.h.

◆ Matrix6b

using momentum::Matrix6b = typedef Matrix6<std::uint8_t>

Definition at line 128 of file types.h.

◆ Matrix6d

using momentum::Matrix6d = typedef Matrix6<double>

Definition at line 120 of file types.h.

◆ Matrix6f

using momentum::Matrix6f = typedef Matrix6<float>

Definition at line 112 of file types.h.

◆ Matrix6i

using momentum::Matrix6i = typedef Matrix6<std::int32_t>

Definition at line 152 of file types.h.

◆ Matrix6s

using momentum::Matrix6s = typedef Matrix6<std::uint16_t>

Definition at line 136 of file types.h.

◆ Matrix6u

using momentum::Matrix6u = typedef Matrix6<std::uint32_t>

Definition at line 144 of file types.h.

◆ MatrixX

template<typename T >

using momentum::MatrixX = typedef Eigen::Matrix<T, Dynamic, Dynamic>

Definition at line 82 of file types.h.

◆ MatrixX3

template<typename T >

using momentum::MatrixX3 = typedef Eigen::Matrix<T, Dynamic, 3>

Definition at line 164 of file types.h.

◆ MatrixX3b

using momentum::MatrixX3b = typedef MatrixX3<std::uint8_t>

Definition at line 167 of file types.h.

◆ MatrixX3d

using momentum::MatrixX3d = typedef MatrixX3<double>

Definition at line 166 of file types.h.

◆ MatrixX3f

using momentum::MatrixX3f = typedef MatrixX3<float>

Definition at line 165 of file types.h.

◆ MatrixX3i

using momentum::MatrixX3i = typedef MatrixX3<std::int32_t>

Definition at line 170 of file types.h.

◆ MatrixX3s

using momentum::MatrixX3s = typedef MatrixX3<std::uint16_t>

Definition at line 168 of file types.h.

◆ MatrixX3u

using momentum::MatrixX3u = typedef MatrixX3<std::uint32_t>

Definition at line 169 of file types.h.

◆ MatrixXb

using momentum::MatrixXb = typedef MatrixX<std::uint8_t>

Definition at line 86 of file types.h.

◆ MatrixXd

using momentum::MatrixXd = typedef MatrixX<double>

Definition at line 85 of file types.h.

◆ MatrixXf

using momentum::MatrixXf = typedef MatrixX<float>

Definition at line 84 of file types.h.

◆ MatrixXi

using momentum::MatrixXi = typedef MatrixX<std::int32_t>

Definition at line 89 of file types.h.

◆ MatrixXs

using momentum::MatrixXs = typedef MatrixX<std::uint16_t>

Definition at line 87 of file types.h.

◆ MatrixXu

using momentum::MatrixXu = typedef MatrixX<std::uint32_t>

Definition at line 88 of file types.h.

◆ Mesh

using momentum::Mesh = typedef MeshT<float>

Definition at line 20 of file fwd.h.

◆ Mesh_const_p

using momentum::Mesh_const_p = typedef ::std::shared_ptr<const Mesh>

Definition at line 26 of file fwd.h.

◆ Mesh_const_u

using momentum::Mesh_const_u = typedef ::std::unique_ptr<const Mesh>

Definition at line 27 of file fwd.h.

◆ Mesh_const_w

using momentum::Mesh_const_w = typedef ::std::weak_ptr<const Mesh>

Definition at line 28 of file fwd.h.

◆ Mesh_p

using momentum::Mesh_p = typedef ::std::shared_ptr<Mesh>

Definition at line 23 of file fwd.h.

◆ Mesh_u

using momentum::Mesh_u = typedef ::std::unique_ptr<Mesh>

Definition at line 24 of file fwd.h.

◆ Mesh_w

using momentum::Mesh_w = typedef ::std::weak_ptr<Mesh>

Definition at line 25 of file fwd.h.

◆ Meshd

using momentum::Meshd = typedef MeshT<double>

Definition at line 21 of file fwd.h.

◆ Meshd_const_p

using momentum::Meshd_const_p = typedef ::std::shared_ptr<const Meshd>

Definition at line 33 of file fwd.h.

◆ Meshd_const_u

using momentum::Meshd_const_u = typedef ::std::unique_ptr<const Meshd>

Definition at line 34 of file fwd.h.

◆ Meshd_const_w

using momentum::Meshd_const_w = typedef ::std::weak_ptr<const Meshd>

Definition at line 35 of file fwd.h.

◆ Meshd_p

using momentum::Meshd_p = typedef ::std::shared_ptr<Meshd>

Definition at line 30 of file fwd.h.

◆ Meshd_u

using momentum::Meshd_u = typedef ::std::unique_ptr<Meshd>

Definition at line 31 of file fwd.h.

◆ Meshd_w

using momentum::Meshd_w = typedef ::std::weak_ptr<Meshd>

Definition at line 32 of file fwd.h.

◆ MeshState

using momentum::MeshState = typedef MeshStateT<float>

Definition at line 226 of file fwd.h.

◆ MeshState_const_p

using momentum::MeshState_const_p = typedef ::std::shared_ptr<const MeshState>

Definition at line 232 of file fwd.h.

◆ MeshState_const_u

using momentum::MeshState_const_u = typedef ::std::unique_ptr<const MeshState>

Definition at line 233 of file fwd.h.

◆ MeshState_const_w

using momentum::MeshState_const_w = typedef ::std::weak_ptr<const MeshState>

Definition at line 234 of file fwd.h.

◆ MeshState_p

using momentum::MeshState_p = typedef ::std::shared_ptr<MeshState>

Definition at line 229 of file fwd.h.

◆ MeshState_u

using momentum::MeshState_u = typedef ::std::unique_ptr<MeshState>

Definition at line 230 of file fwd.h.

◆ MeshState_w

using momentum::MeshState_w = typedef ::std::weak_ptr<MeshState>

Definition at line 231 of file fwd.h.

◆ MeshStated

using momentum::MeshStated = typedef MeshStateT<double>

Definition at line 227 of file fwd.h.

◆ MeshStated_const_p

using momentum::MeshStated_const_p = typedef ::std::shared_ptr<const MeshStated>

Definition at line 239 of file fwd.h.

◆ MeshStated_const_u

using momentum::MeshStated_const_u = typedef ::std::unique_ptr<const MeshStated>

Definition at line 240 of file fwd.h.

◆ MeshStated_const_w

using momentum::MeshStated_const_w = typedef ::std::weak_ptr<const MeshStated>

Definition at line 241 of file fwd.h.

◆ MeshStated_p

using momentum::MeshStated_p = typedef ::std::shared_ptr<MeshStated>

Definition at line 236 of file fwd.h.

◆ MeshStated_u

using momentum::MeshStated_u = typedef ::std::unique_ptr<MeshStated>

Definition at line 237 of file fwd.h.

◆ MeshStated_w

using momentum::MeshStated_w = typedef ::std::weak_ptr<MeshStated>

Definition at line 238 of file fwd.h.

◆ ModelParameters

using momentum::ModelParameters = typedef ModelParametersT<float>

Definition at line 109 of file types.h.

◆ ModelParametersd

using momentum::ModelParametersd = typedef ModelParametersT<double>

Definition at line 110 of file types.h.

◆ ModelParametersErrorFunction

using momentum::ModelParametersErrorFunction = typedef ModelParametersErrorFunctionT<float>

Definition at line 554 of file fwd.h.

◆ ModelParametersErrorFunction_const_p

using momentum::ModelParametersErrorFunction_const_p = typedef ::std::shared_ptr<const ModelParametersErrorFunction>

Definition at line 560 of file fwd.h.

◆ ModelParametersErrorFunction_const_u

using momentum::ModelParametersErrorFunction_const_u = typedef ::std::unique_ptr<const ModelParametersErrorFunction>

Definition at line 561 of file fwd.h.

◆ ModelParametersErrorFunction_const_w

using momentum::ModelParametersErrorFunction_const_w = typedef ::std::weak_ptr<const ModelParametersErrorFunction>

Definition at line 562 of file fwd.h.

◆ ModelParametersErrorFunction_p

using momentum::ModelParametersErrorFunction_p = typedef ::std::shared_ptr<ModelParametersErrorFunction>

Definition at line 557 of file fwd.h.

◆ ModelParametersErrorFunction_u

using momentum::ModelParametersErrorFunction_u = typedef ::std::unique_ptr<ModelParametersErrorFunction>

Definition at line 558 of file fwd.h.

◆ ModelParametersErrorFunction_w

using momentum::ModelParametersErrorFunction_w = typedef ::std::weak_ptr<ModelParametersErrorFunction>

Definition at line 559 of file fwd.h.

◆ ModelParametersErrorFunctiond

using momentum::ModelParametersErrorFunctiond = typedef ModelParametersErrorFunctionT<double>

Definition at line 555 of file fwd.h.

◆ ModelParametersErrorFunctiond_const_p

using momentum::ModelParametersErrorFunctiond_const_p = typedef ::std::shared_ptr<const ModelParametersErrorFunctiond>

Definition at line 567 of file fwd.h.

◆ ModelParametersErrorFunctiond_const_u

using momentum::ModelParametersErrorFunctiond_const_u = typedef ::std::unique_ptr<const ModelParametersErrorFunctiond>

Definition at line 569 of file fwd.h.

◆ ModelParametersErrorFunctiond_const_w

using momentum::ModelParametersErrorFunctiond_const_w = typedef ::std::weak_ptr<const ModelParametersErrorFunctiond>

Definition at line 571 of file fwd.h.

◆ ModelParametersErrorFunctiond_p

using momentum::ModelParametersErrorFunctiond_p = typedef ::std::shared_ptr<ModelParametersErrorFunctiond>

Definition at line 564 of file fwd.h.

◆ ModelParametersErrorFunctiond_u

using momentum::ModelParametersErrorFunctiond_u = typedef ::std::unique_ptr<ModelParametersErrorFunctiond>

Definition at line 565 of file fwd.h.

◆ ModelParametersErrorFunctiond_w

using momentum::ModelParametersErrorFunctiond_w = typedef ::std::weak_ptr<ModelParametersErrorFunctiond>

Definition at line 566 of file fwd.h.

◆ ModelParametersSequenceErrorFunction

using momentum::ModelParametersSequenceErrorFunction = typedef ModelParametersSequenceErrorFunctionT<float>

Definition at line 57 of file fwd.h.

◆ ModelParametersSequenceErrorFunction_const_p

using momentum::ModelParametersSequenceErrorFunction_const_p = typedef ::std::shared_ptr<const ModelParametersSequenceErrorFunction>

Definition at line 66 of file fwd.h.

◆ ModelParametersSequenceErrorFunction_const_u

using momentum::ModelParametersSequenceErrorFunction_const_u = typedef ::std::unique_ptr<const ModelParametersSequenceErrorFunction>

Definition at line 68 of file fwd.h.

◆ ModelParametersSequenceErrorFunction_const_w

using momentum::ModelParametersSequenceErrorFunction_const_w = typedef ::std::weak_ptr<const ModelParametersSequenceErrorFunction>

Definition at line 70 of file fwd.h.

◆ ModelParametersSequenceErrorFunction_p

using momentum::ModelParametersSequenceErrorFunction_p = typedef ::std::shared_ptr<ModelParametersSequenceErrorFunction>

Definition at line 60 of file fwd.h.

◆ ModelParametersSequenceErrorFunction_u

using momentum::ModelParametersSequenceErrorFunction_u = typedef ::std::unique_ptr<ModelParametersSequenceErrorFunction>

Definition at line 62 of file fwd.h.

◆ ModelParametersSequenceErrorFunction_w

using momentum::ModelParametersSequenceErrorFunction_w = typedef ::std::weak_ptr<ModelParametersSequenceErrorFunction>

Definition at line 64 of file fwd.h.

◆ ModelParametersSequenceErrorFunctiond

using momentum::ModelParametersSequenceErrorFunctiond = typedef ModelParametersSequenceErrorFunctionT<double>

Definition at line 58 of file fwd.h.

◆ ModelParametersSequenceErrorFunctiond_const_p

using momentum::ModelParametersSequenceErrorFunctiond_const_p = typedef ::std::shared_ptr<const ModelParametersSequenceErrorFunctiond>

Definition at line 79 of file fwd.h.

◆ ModelParametersSequenceErrorFunctiond_const_u

using momentum::ModelParametersSequenceErrorFunctiond_const_u = typedef ::std::unique_ptr<const ModelParametersSequenceErrorFunctiond>

Definition at line 81 of file fwd.h.

◆ ModelParametersSequenceErrorFunctiond_const_w

using momentum::ModelParametersSequenceErrorFunctiond_const_w = typedef ::std::weak_ptr<const ModelParametersSequenceErrorFunctiond>

Definition at line 83 of file fwd.h.

◆ ModelParametersSequenceErrorFunctiond_p

using momentum::ModelParametersSequenceErrorFunctiond_p = typedef ::std::shared_ptr<ModelParametersSequenceErrorFunctiond>

Definition at line 73 of file fwd.h.

◆ ModelParametersSequenceErrorFunctiond_u

using momentum::ModelParametersSequenceErrorFunctiond_u = typedef ::std::unique_ptr<ModelParametersSequenceErrorFunctiond>

Definition at line 75 of file fwd.h.

◆ ModelParametersSequenceErrorFunctiond_w

using momentum::ModelParametersSequenceErrorFunctiond_w = typedef ::std::weak_ptr<ModelParametersSequenceErrorFunctiond>

Definition at line 77 of file fwd.h.

◆ MotionParameters

typedef std::tuple< std::vector< std::string >, MatrixXf > momentum::MotionParameters

Definition at line 190 of file types.h.

◆ Mppca

using momentum::Mppca = typedef MppcaT<float>

Definition at line 39 of file fwd.h.

◆ Mppca_const_p

using momentum::Mppca_const_p = typedef ::std::shared_ptr<const Mppca>

Definition at line 45 of file fwd.h.

◆ Mppca_const_u

using momentum::Mppca_const_u = typedef ::std::unique_ptr<const Mppca>

Definition at line 46 of file fwd.h.

◆ Mppca_const_w

using momentum::Mppca_const_w = typedef ::std::weak_ptr<const Mppca>

Definition at line 47 of file fwd.h.

◆ Mppca_p

using momentum::Mppca_p = typedef ::std::shared_ptr<Mppca>

Definition at line 42 of file fwd.h.

◆ Mppca_u

using momentum::Mppca_u = typedef ::std::unique_ptr<Mppca>

Definition at line 43 of file fwd.h.

◆ Mppca_w

using momentum::Mppca_w = typedef ::std::weak_ptr<Mppca>

Definition at line 44 of file fwd.h.

◆ Mppcad

using momentum::Mppcad = typedef MppcaT<double>

Definition at line 40 of file fwd.h.

◆ Mppcad_const_p

using momentum::Mppcad_const_p = typedef ::std::shared_ptr<const Mppcad>

Definition at line 52 of file fwd.h.

◆ Mppcad_const_u

using momentum::Mppcad_const_u = typedef ::std::unique_ptr<const Mppcad>

Definition at line 53 of file fwd.h.

◆ Mppcad_const_w

using momentum::Mppcad_const_w = typedef ::std::weak_ptr<const Mppcad>

Definition at line 54 of file fwd.h.

◆ Mppcad_p

using momentum::Mppcad_p = typedef ::std::shared_ptr<Mppcad>

Definition at line 49 of file fwd.h.

◆ Mppcad_u

using momentum::Mppcad_u = typedef ::std::unique_ptr<Mppcad>

Definition at line 50 of file fwd.h.

◆ Mppcad_w

using momentum::Mppcad_w = typedef ::std::weak_ptr<Mppcad>

Definition at line 51 of file fwd.h.

◆ MultiposeSolver

using momentum::MultiposeSolver = typedef MultiposeSolverT<float>

Definition at line 88 of file fwd.h.

◆ MultiposeSolver_const_p

using momentum::MultiposeSolver_const_p = typedef ::std::shared_ptr<const MultiposeSolver>

Definition at line 94 of file fwd.h.

◆ MultiposeSolver_const_u

using momentum::MultiposeSolver_const_u = typedef ::std::unique_ptr<const MultiposeSolver>

Definition at line 95 of file fwd.h.

◆ MultiposeSolver_const_w

using momentum::MultiposeSolver_const_w = typedef ::std::weak_ptr<const MultiposeSolver>

Definition at line 96 of file fwd.h.

◆ MultiposeSolver_p

using momentum::MultiposeSolver_p = typedef ::std::shared_ptr<MultiposeSolver>

Definition at line 91 of file fwd.h.

◆ MultiposeSolver_u

using momentum::MultiposeSolver_u = typedef ::std::unique_ptr<MultiposeSolver>

Definition at line 92 of file fwd.h.

◆ MultiposeSolver_w

using momentum::MultiposeSolver_w = typedef ::std::weak_ptr<MultiposeSolver>

Definition at line 93 of file fwd.h.

◆ MultiposeSolverd

using momentum::MultiposeSolverd = typedef MultiposeSolverT<double>

Definition at line 89 of file fwd.h.

◆ MultiposeSolverd_const_p

using momentum::MultiposeSolverd_const_p = typedef ::std::shared_ptr<const MultiposeSolverd>

Definition at line 101 of file fwd.h.

◆ MultiposeSolverd_const_u

using momentum::MultiposeSolverd_const_u = typedef ::std::unique_ptr<const MultiposeSolverd>

Definition at line 102 of file fwd.h.

◆ MultiposeSolverd_const_w

using momentum::MultiposeSolverd_const_w = typedef ::std::weak_ptr<const MultiposeSolverd>

Definition at line 103 of file fwd.h.

◆ MultiposeSolverd_p

using momentum::MultiposeSolverd_p = typedef ::std::shared_ptr<MultiposeSolverd>

Definition at line 98 of file fwd.h.

◆ MultiposeSolverd_u

using momentum::MultiposeSolverd_u = typedef ::std::unique_ptr<MultiposeSolverd>

Definition at line 99 of file fwd.h.

◆ MultiposeSolverd_w

using momentum::MultiposeSolverd_w = typedef ::std::weak_ptr<MultiposeSolverd>

Definition at line 100 of file fwd.h.

◆ MultiposeSolverFunction

using momentum::MultiposeSolverFunction = typedef MultiposeSolverFunctionT<float>

Definition at line 107 of file fwd.h.

◆ MultiposeSolverFunction_const_p

using momentum::MultiposeSolverFunction_const_p = typedef ::std::shared_ptr<const MultiposeSolverFunction>

Definition at line 113 of file fwd.h.

◆ MultiposeSolverFunction_const_u

using momentum::MultiposeSolverFunction_const_u = typedef ::std::unique_ptr<const MultiposeSolverFunction>

Definition at line 114 of file fwd.h.

◆ MultiposeSolverFunction_const_w

using momentum::MultiposeSolverFunction_const_w = typedef ::std::weak_ptr<const MultiposeSolverFunction>

Definition at line 115 of file fwd.h.

◆ MultiposeSolverFunction_p

using momentum::MultiposeSolverFunction_p = typedef ::std::shared_ptr<MultiposeSolverFunction>

Definition at line 110 of file fwd.h.

◆ MultiposeSolverFunction_u

using momentum::MultiposeSolverFunction_u = typedef ::std::unique_ptr<MultiposeSolverFunction>

Definition at line 111 of file fwd.h.

◆ MultiposeSolverFunction_w

using momentum::MultiposeSolverFunction_w = typedef ::std::weak_ptr<MultiposeSolverFunction>

Definition at line 112 of file fwd.h.

◆ MultiposeSolverFunctiond

using momentum::MultiposeSolverFunctiond = typedef MultiposeSolverFunctionT<double>

Definition at line 108 of file fwd.h.

◆ MultiposeSolverFunctiond_const_p

using momentum::MultiposeSolverFunctiond_const_p = typedef ::std::shared_ptr<const MultiposeSolverFunctiond>

Definition at line 120 of file fwd.h.

◆ MultiposeSolverFunctiond_const_u

using momentum::MultiposeSolverFunctiond_const_u = typedef ::std::unique_ptr<const MultiposeSolverFunctiond>

Definition at line 121 of file fwd.h.

◆ MultiposeSolverFunctiond_const_w

using momentum::MultiposeSolverFunctiond_const_w = typedef ::std::weak_ptr<const MultiposeSolverFunctiond>

Definition at line 122 of file fwd.h.

◆ MultiposeSolverFunctiond_p

using momentum::MultiposeSolverFunctiond_p = typedef ::std::shared_ptr<MultiposeSolverFunctiond>

Definition at line 117 of file fwd.h.

◆ MultiposeSolverFunctiond_u

using momentum::MultiposeSolverFunctiond_u = typedef ::std::unique_ptr<MultiposeSolverFunctiond>

Definition at line 118 of file fwd.h.

◆ MultiposeSolverFunctiond_w

using momentum::MultiposeSolverFunctiond_w = typedef ::std::weak_ptr<MultiposeSolverFunctiond>

Definition at line 119 of file fwd.h.

◆ MultiposeSolverOptions_const_p

using momentum::MultiposeSolverOptions_const_p = typedef ::std::shared_ptr<const MultiposeSolverOptions>

Definition at line 23 of file fwd.h.

◆ MultiposeSolverOptions_const_u

using momentum::MultiposeSolverOptions_const_u = typedef ::std::unique_ptr<const MultiposeSolverOptions>

Definition at line 24 of file fwd.h.

◆ MultiposeSolverOptions_const_w

using momentum::MultiposeSolverOptions_const_w = typedef ::std::weak_ptr<const MultiposeSolverOptions>

Definition at line 25 of file fwd.h.

◆ MultiposeSolverOptions_p

using momentum::MultiposeSolverOptions_p = typedef ::std::shared_ptr<MultiposeSolverOptions>

Definition at line 20 of file fwd.h.

◆ MultiposeSolverOptions_u

using momentum::MultiposeSolverOptions_u = typedef ::std::unique_ptr<MultiposeSolverOptions>

Definition at line 21 of file fwd.h.

◆ MultiposeSolverOptions_w

using momentum::MultiposeSolverOptions_w = typedef ::std::weak_ptr<MultiposeSolverOptions>

Definition at line 22 of file fwd.h.

◆ NormalArray

using momentum::NormalArray = typedef Matrix3Xf

Definition at line 396 of file types.h.

◆ NormalData

using momentum::NormalData = typedef NormalDataT<float>

Definition at line 103 of file fwd.h.

◆ NormalData_const_p

using momentum::NormalData_const_p = typedef ::std::shared_ptr<const NormalData>

Definition at line 109 of file fwd.h.

◆ NormalData_const_u

using momentum::NormalData_const_u = typedef ::std::unique_ptr<const NormalData>

Definition at line 110 of file fwd.h.

◆ NormalData_const_w

using momentum::NormalData_const_w = typedef ::std::weak_ptr<const NormalData>

Definition at line 111 of file fwd.h.

◆ NormalData_p

using momentum::NormalData_p = typedef ::std::shared_ptr<NormalData>

Definition at line 106 of file fwd.h.

◆ NormalData_u

using momentum::NormalData_u = typedef ::std::unique_ptr<NormalData>

Definition at line 107 of file fwd.h.

◆ NormalData_w

using momentum::NormalData_w = typedef ::std::weak_ptr<NormalData>

Definition at line 108 of file fwd.h.

◆ NormalDatad

using momentum::NormalDatad = typedef NormalDataT<double>

Definition at line 104 of file fwd.h.

◆ NormalDatad_const_p

using momentum::NormalDatad_const_p = typedef ::std::shared_ptr<const NormalDatad>

Definition at line 116 of file fwd.h.

◆ NormalDatad_const_u

using momentum::NormalDatad_const_u = typedef ::std::unique_ptr<const NormalDatad>

Definition at line 117 of file fwd.h.

◆ NormalDatad_const_w

using momentum::NormalDatad_const_w = typedef ::std::weak_ptr<const NormalDatad>

Definition at line 118 of file fwd.h.

◆ NormalDatad_p

using momentum::NormalDatad_p = typedef ::std::shared_ptr<NormalDatad>

Definition at line 113 of file fwd.h.

◆ NormalDatad_u

using momentum::NormalDatad_u = typedef ::std::unique_ptr<NormalDatad>

Definition at line 114 of file fwd.h.

◆ NormalDatad_w

using momentum::NormalDatad_w = typedef ::std::weak_ptr<NormalDatad>

Definition at line 115 of file fwd.h.

◆ NormalErrorFunction

using momentum::NormalErrorFunction = typedef NormalErrorFunctionT<float>

Definition at line 575 of file fwd.h.

◆ NormalErrorFunction_const_p

using momentum::NormalErrorFunction_const_p = typedef ::std::shared_ptr<const NormalErrorFunction>

Definition at line 581 of file fwd.h.

◆ NormalErrorFunction_const_u

using momentum::NormalErrorFunction_const_u = typedef ::std::unique_ptr<const NormalErrorFunction>

Definition at line 582 of file fwd.h.

◆ NormalErrorFunction_const_w

using momentum::NormalErrorFunction_const_w = typedef ::std::weak_ptr<const NormalErrorFunction>

Definition at line 583 of file fwd.h.

◆ NormalErrorFunction_p

using momentum::NormalErrorFunction_p = typedef ::std::shared_ptr<NormalErrorFunction>

Definition at line 578 of file fwd.h.

◆ NormalErrorFunction_u

using momentum::NormalErrorFunction_u = typedef ::std::unique_ptr<NormalErrorFunction>

Definition at line 579 of file fwd.h.

◆ NormalErrorFunction_w

using momentum::NormalErrorFunction_w = typedef ::std::weak_ptr<NormalErrorFunction>

Definition at line 580 of file fwd.h.

◆ NormalErrorFunctiond

using momentum::NormalErrorFunctiond = typedef NormalErrorFunctionT<double>

Definition at line 576 of file fwd.h.

◆ NormalErrorFunctiond_const_p

using momentum::NormalErrorFunctiond_const_p = typedef ::std::shared_ptr<const NormalErrorFunctiond>

Definition at line 588 of file fwd.h.

◆ NormalErrorFunctiond_const_u

using momentum::NormalErrorFunctiond_const_u = typedef ::std::unique_ptr<const NormalErrorFunctiond>

Definition at line 589 of file fwd.h.

◆ NormalErrorFunctiond_const_w

using momentum::NormalErrorFunctiond_const_w = typedef ::std::weak_ptr<const NormalErrorFunctiond>

Definition at line 590 of file fwd.h.

◆ NormalErrorFunctiond_p

using momentum::NormalErrorFunctiond_p = typedef ::std::shared_ptr<NormalErrorFunctiond>

Definition at line 585 of file fwd.h.

◆ NormalErrorFunctiond_u

using momentum::NormalErrorFunctiond_u = typedef ::std::unique_ptr<NormalErrorFunctiond>

Definition at line 586 of file fwd.h.

◆ NormalErrorFunctiond_w

using momentum::NormalErrorFunctiond_w = typedef ::std::weak_ptr<NormalErrorFunctiond>

Definition at line 587 of file fwd.h.

◆ optional_ref

template<typename T >

using momentum::optional_ref = typedef std::optional<std::reference_wrapper<T> >

An optional of a reference.

Because optional<T&> is invalid, we need to use reference_wrapper to make the reference of T as an optional.

Definition at line 39 of file constraint_error_function.h.

◆ OrientationConstraint

using momentum::OrientationConstraint = typedef OrientationConstraintT<float>

Definition at line 39 of file fwd.h.

◆ OrientationConstraint_const_p

using momentum::OrientationConstraint_const_p = typedef ::std::shared_ptr<const OrientationConstraint>

Definition at line 45 of file fwd.h.

◆ OrientationConstraint_const_u

using momentum::OrientationConstraint_const_u = typedef ::std::unique_ptr<const OrientationConstraint>

Definition at line 46 of file fwd.h.

◆ OrientationConstraint_const_w

using momentum::OrientationConstraint_const_w = typedef ::std::weak_ptr<const OrientationConstraint>

Definition at line 47 of file fwd.h.

◆ OrientationConstraint_p

using momentum::OrientationConstraint_p = typedef ::std::shared_ptr<OrientationConstraint>

Definition at line 42 of file fwd.h.

◆ OrientationConstraint_u

using momentum::OrientationConstraint_u = typedef ::std::unique_ptr<OrientationConstraint>

Definition at line 43 of file fwd.h.

◆ OrientationConstraint_w

using momentum::OrientationConstraint_w = typedef ::std::weak_ptr<OrientationConstraint>

Definition at line 44 of file fwd.h.

◆ OrientationConstraintd

using momentum::OrientationConstraintd = typedef OrientationConstraintT<double>

Definition at line 40 of file fwd.h.

◆ OrientationConstraintd_const_p

using momentum::OrientationConstraintd_const_p = typedef ::std::shared_ptr<const OrientationConstraintd>

Definition at line 52 of file fwd.h.

◆ OrientationConstraintd_const_u

using momentum::OrientationConstraintd_const_u = typedef ::std::unique_ptr<const OrientationConstraintd>

Definition at line 53 of file fwd.h.

◆ OrientationConstraintd_const_w

using momentum::OrientationConstraintd_const_w = typedef ::std::weak_ptr<const OrientationConstraintd>

Definition at line 54 of file fwd.h.

◆ OrientationConstraintd_p

using momentum::OrientationConstraintd_p = typedef ::std::shared_ptr<OrientationConstraintd>

Definition at line 49 of file fwd.h.

◆ OrientationConstraintd_u

using momentum::OrientationConstraintd_u = typedef ::std::unique_ptr<OrientationConstraintd>

Definition at line 50 of file fwd.h.

◆ OrientationConstraintd_w

using momentum::OrientationConstraintd_w = typedef ::std::weak_ptr<OrientationConstraintd>

Definition at line 51 of file fwd.h.

◆ OrientationConstraintState

using momentum::OrientationConstraintState = typedef OrientationConstraintStateT<float>

Definition at line 58 of file fwd.h.

◆ OrientationConstraintState_const_p

using momentum::OrientationConstraintState_const_p = typedef ::std::shared_ptr<const OrientationConstraintState>

Definition at line 64 of file fwd.h.

◆ OrientationConstraintState_const_u

using momentum::OrientationConstraintState_const_u = typedef ::std::unique_ptr<const OrientationConstraintState>

Definition at line 65 of file fwd.h.

◆ OrientationConstraintState_const_w

using momentum::OrientationConstraintState_const_w = typedef ::std::weak_ptr<const OrientationConstraintState>

Definition at line 66 of file fwd.h.

◆ OrientationConstraintState_p

using momentum::OrientationConstraintState_p = typedef ::std::shared_ptr<OrientationConstraintState>

Definition at line 61 of file fwd.h.

◆ OrientationConstraintState_u

using momentum::OrientationConstraintState_u = typedef ::std::unique_ptr<OrientationConstraintState>

Definition at line 62 of file fwd.h.

◆ OrientationConstraintState_w

using momentum::OrientationConstraintState_w = typedef ::std::weak_ptr<OrientationConstraintState>

Definition at line 63 of file fwd.h.

◆ OrientationConstraintStated

using momentum::OrientationConstraintStated = typedef OrientationConstraintStateT<double>

Definition at line 59 of file fwd.h.

◆ OrientationConstraintStated_const_p

using momentum::OrientationConstraintStated_const_p = typedef ::std::shared_ptr<const OrientationConstraintStated>

Definition at line 71 of file fwd.h.

◆ OrientationConstraintStated_const_u

using momentum::OrientationConstraintStated_const_u = typedef ::std::unique_ptr<const OrientationConstraintStated>

Definition at line 72 of file fwd.h.

◆ OrientationConstraintStated_const_w

using momentum::OrientationConstraintStated_const_w = typedef ::std::weak_ptr<const OrientationConstraintStated>

Definition at line 73 of file fwd.h.

◆ OrientationConstraintStated_p

using momentum::OrientationConstraintStated_p = typedef ::std::shared_ptr<OrientationConstraintStated>

Definition at line 68 of file fwd.h.

◆ OrientationConstraintStated_u

using momentum::OrientationConstraintStated_u = typedef ::std::unique_ptr<OrientationConstraintStated>

Definition at line 69 of file fwd.h.

◆ OrientationConstraintStated_w

using momentum::OrientationConstraintStated_w = typedef ::std::weak_ptr<OrientationConstraintStated>

Definition at line 70 of file fwd.h.

◆ OrientationData

using momentum::OrientationData = typedef OrientationDataT<float>

Definition at line 122 of file fwd.h.

◆ OrientationData_const_p

using momentum::OrientationData_const_p = typedef ::std::shared_ptr<const OrientationData>

Definition at line 128 of file fwd.h.

◆ OrientationData_const_u

using momentum::OrientationData_const_u = typedef ::std::unique_ptr<const OrientationData>

Definition at line 129 of file fwd.h.

◆ OrientationData_const_w

using momentum::OrientationData_const_w = typedef ::std::weak_ptr<const OrientationData>

Definition at line 130 of file fwd.h.

◆ OrientationData_p

using momentum::OrientationData_p = typedef ::std::shared_ptr<OrientationData>

Definition at line 125 of file fwd.h.

◆ OrientationData_u

using momentum::OrientationData_u = typedef ::std::unique_ptr<OrientationData>

Definition at line 126 of file fwd.h.

◆ OrientationData_w

using momentum::OrientationData_w = typedef ::std::weak_ptr<OrientationData>

Definition at line 127 of file fwd.h.

◆ OrientationDatad

using momentum::OrientationDatad = typedef OrientationDataT<double>

Definition at line 123 of file fwd.h.

◆ OrientationDatad_const_p

using momentum::OrientationDatad_const_p = typedef ::std::shared_ptr<const OrientationDatad>

Definition at line 135 of file fwd.h.

◆ OrientationDatad_const_u

using momentum::OrientationDatad_const_u = typedef ::std::unique_ptr<const OrientationDatad>

Definition at line 136 of file fwd.h.

◆ OrientationDatad_const_w

using momentum::OrientationDatad_const_w = typedef ::std::weak_ptr<const OrientationDatad>

Definition at line 137 of file fwd.h.

◆ OrientationDatad_p

using momentum::OrientationDatad_p = typedef ::std::shared_ptr<OrientationDatad>

Definition at line 132 of file fwd.h.

◆ OrientationDatad_u

using momentum::OrientationDatad_u = typedef ::std::unique_ptr<OrientationDatad>

Definition at line 133 of file fwd.h.

◆ OrientationDatad_w

using momentum::OrientationDatad_w = typedef ::std::weak_ptr<OrientationDatad>

Definition at line 134 of file fwd.h.

◆ OrientationErrorFunction

using momentum::OrientationErrorFunction = typedef OrientationErrorFunctionT<float>

Definition at line 594 of file fwd.h.

◆ OrientationErrorFunction_const_p

using momentum::OrientationErrorFunction_const_p = typedef ::std::shared_ptr<const OrientationErrorFunction>

Definition at line 600 of file fwd.h.

◆ OrientationErrorFunction_const_u

using momentum::OrientationErrorFunction_const_u = typedef ::std::unique_ptr<const OrientationErrorFunction>

Definition at line 601 of file fwd.h.

◆ OrientationErrorFunction_const_w

using momentum::OrientationErrorFunction_const_w = typedef ::std::weak_ptr<const OrientationErrorFunction>

Definition at line 602 of file fwd.h.

◆ OrientationErrorFunction_p

using momentum::OrientationErrorFunction_p = typedef ::std::shared_ptr<OrientationErrorFunction>

Definition at line 597 of file fwd.h.

◆ OrientationErrorFunction_u

using momentum::OrientationErrorFunction_u = typedef ::std::unique_ptr<OrientationErrorFunction>

Definition at line 598 of file fwd.h.

◆ OrientationErrorFunction_w

using momentum::OrientationErrorFunction_w = typedef ::std::weak_ptr<OrientationErrorFunction>

Definition at line 599 of file fwd.h.

◆ OrientationErrorFunctiond

using momentum::OrientationErrorFunctiond = typedef OrientationErrorFunctionT<double>

Definition at line 595 of file fwd.h.

◆ OrientationErrorFunctiond_const_p

using momentum::OrientationErrorFunctiond_const_p = typedef ::std::shared_ptr<const OrientationErrorFunctiond>

Definition at line 607 of file fwd.h.

◆ OrientationErrorFunctiond_const_u

using momentum::OrientationErrorFunctiond_const_u = typedef ::std::unique_ptr<const OrientationErrorFunctiond>

Definition at line 608 of file fwd.h.

◆ OrientationErrorFunctiond_const_w

using momentum::OrientationErrorFunctiond_const_w = typedef ::std::weak_ptr<const OrientationErrorFunctiond>

Definition at line 609 of file fwd.h.

◆ OrientationErrorFunctiond_p

using momentum::OrientationErrorFunctiond_p = typedef ::std::shared_ptr<OrientationErrorFunctiond>

Definition at line 604 of file fwd.h.

◆ OrientationErrorFunctiond_u

using momentum::OrientationErrorFunctiond_u = typedef ::std::unique_ptr<OrientationErrorFunctiond>

Definition at line 605 of file fwd.h.

◆ OrientationErrorFunctiond_w

using momentum::OrientationErrorFunctiond_w = typedef ::std::weak_ptr<OrientationErrorFunctiond>

Definition at line 606 of file fwd.h.

◆ Packet

template<typename T >

using momentum::Packet = typedef drjit::Packet<T, kSimdPacketSize>

Definition at line 38 of file simd.h.

◆ ParameterLimits

using momentum::ParameterLimits = typedef std::vector<ParameterLimit>

Definition at line 124 of file parameter_limits.h.

◆ ParameterSet

using momentum::ParameterSet = typedef std::bitset<kMaxModelParams>

Definition at line 402 of file types.h.

◆ ParameterSets

using momentum::ParameterSets = typedef std::unordered_map<std::string, ParameterSet>

Definition at line 32 of file parameter_transform.h.

◆ ParameterTransform

typedef ParameterTransformT< float > momentum::ParameterTransform

Definition at line 169 of file fwd.h.

◆ ParameterTransform_const_p

using momentum::ParameterTransform_const_p = typedef ::std::shared_ptr<const ParameterTransform>

Definition at line 175 of file fwd.h.

◆ ParameterTransform_const_u

using momentum::ParameterTransform_const_u = typedef ::std::unique_ptr<const ParameterTransform>

Definition at line 176 of file fwd.h.

◆ ParameterTransform_const_w

using momentum::ParameterTransform_const_w = typedef ::std::weak_ptr<const ParameterTransform>

Definition at line 177 of file fwd.h.

◆ ParameterTransform_p

using momentum::ParameterTransform_p = typedef ::std::shared_ptr<ParameterTransform>

Definition at line 172 of file fwd.h.

◆ ParameterTransform_u

using momentum::ParameterTransform_u = typedef ::std::unique_ptr<ParameterTransform>

Definition at line 173 of file fwd.h.

◆ ParameterTransform_w

using momentum::ParameterTransform_w = typedef ::std::weak_ptr<ParameterTransform>

Definition at line 174 of file fwd.h.

◆ ParameterTransformd

typedef ParameterTransformT< double > momentum::ParameterTransformd

Definition at line 170 of file fwd.h.

◆ ParameterTransformd_const_p

using momentum::ParameterTransformd_const_p = typedef ::std::shared_ptr<const ParameterTransformd>

Definition at line 182 of file fwd.h.

◆ ParameterTransformd_const_u

using momentum::ParameterTransformd_const_u = typedef ::std::unique_ptr<const ParameterTransformd>

Definition at line 183 of file fwd.h.

◆ ParameterTransformd_const_w

using momentum::ParameterTransformd_const_w = typedef ::std::weak_ptr<const ParameterTransformd>

Definition at line 184 of file fwd.h.

◆ ParameterTransformd_p

using momentum::ParameterTransformd_p = typedef ::std::shared_ptr<ParameterTransformd>

Definition at line 179 of file fwd.h.

◆ ParameterTransformd_u

using momentum::ParameterTransformd_u = typedef ::std::unique_ptr<ParameterTransformd>

Definition at line 180 of file fwd.h.

◆ ParameterTransformd_w

using momentum::ParameterTransformd_w = typedef ::std::weak_ptr<ParameterTransformd>

Definition at line 181 of file fwd.h.

◆ Plane

template<typename Scalar , int Dim>

using momentum::Plane = typedef Eigen::Hyperplane<Scalar, Dim>

Definition at line 53 of file types.h.

◆ PlaneData

using momentum::PlaneData = typedef PlaneDataT<float>

Definition at line 165 of file fwd.h.

◆ PlaneData_const_p

using momentum::PlaneData_const_p = typedef ::std::shared_ptr<const PlaneData>

Definition at line 171 of file fwd.h.

◆ PlaneData_const_u

using momentum::PlaneData_const_u = typedef ::std::unique_ptr<const PlaneData>

Definition at line 172 of file fwd.h.

◆ PlaneData_const_w

using momentum::PlaneData_const_w = typedef ::std::weak_ptr<const PlaneData>

Definition at line 173 of file fwd.h.

◆ PlaneData_p

using momentum::PlaneData_p = typedef ::std::shared_ptr<PlaneData>

Definition at line 168 of file fwd.h.

◆ PlaneData_u

using momentum::PlaneData_u = typedef ::std::unique_ptr<PlaneData>

Definition at line 169 of file fwd.h.

◆ PlaneData_w

using momentum::PlaneData_w = typedef ::std::weak_ptr<PlaneData>

Definition at line 170 of file fwd.h.

◆ PlaneDatad

using momentum::PlaneDatad = typedef PlaneDataT<double>

Definition at line 166 of file fwd.h.

◆ PlaneDatad_const_p

using momentum::PlaneDatad_const_p = typedef ::std::shared_ptr<const PlaneDatad>

Definition at line 178 of file fwd.h.

◆ PlaneDatad_const_u

using momentum::PlaneDatad_const_u = typedef ::std::unique_ptr<const PlaneDatad>

Definition at line 179 of file fwd.h.

◆ PlaneDatad_const_w

using momentum::PlaneDatad_const_w = typedef ::std::weak_ptr<const PlaneDatad>

Definition at line 180 of file fwd.h.

◆ PlaneDatad_p

using momentum::PlaneDatad_p = typedef ::std::shared_ptr<PlaneDatad>

Definition at line 175 of file fwd.h.

◆ PlaneDatad_u

using momentum::PlaneDatad_u = typedef ::std::unique_ptr<PlaneDatad>

Definition at line 176 of file fwd.h.

◆ PlaneDatad_w

using momentum::PlaneDatad_w = typedef ::std::weak_ptr<PlaneDatad>

Definition at line 177 of file fwd.h.

◆ PlaneErrorFunction

using momentum::PlaneErrorFunction = typedef PlaneErrorFunctionT<float>

Definition at line 613 of file fwd.h.

◆ PlaneErrorFunction_const_p

using momentum::PlaneErrorFunction_const_p = typedef ::std::shared_ptr<const PlaneErrorFunction>

Definition at line 619 of file fwd.h.

◆ PlaneErrorFunction_const_u

using momentum::PlaneErrorFunction_const_u = typedef ::std::unique_ptr<const PlaneErrorFunction>

Definition at line 620 of file fwd.h.

◆ PlaneErrorFunction_const_w

using momentum::PlaneErrorFunction_const_w = typedef ::std::weak_ptr<const PlaneErrorFunction>

Definition at line 621 of file fwd.h.

◆ PlaneErrorFunction_p

using momentum::PlaneErrorFunction_p = typedef ::std::shared_ptr<PlaneErrorFunction>

Definition at line 616 of file fwd.h.

◆ PlaneErrorFunction_u

using momentum::PlaneErrorFunction_u = typedef ::std::unique_ptr<PlaneErrorFunction>

Definition at line 617 of file fwd.h.

◆ PlaneErrorFunction_w

using momentum::PlaneErrorFunction_w = typedef ::std::weak_ptr<PlaneErrorFunction>

Definition at line 618 of file fwd.h.

◆ PlaneErrorFunctiond

using momentum::PlaneErrorFunctiond = typedef PlaneErrorFunctionT<double>

Definition at line 614 of file fwd.h.

◆ PlaneErrorFunctiond_const_p

using momentum::PlaneErrorFunctiond_const_p = typedef ::std::shared_ptr<const PlaneErrorFunctiond>

Definition at line 626 of file fwd.h.

◆ PlaneErrorFunctiond_const_u

using momentum::PlaneErrorFunctiond_const_u = typedef ::std::unique_ptr<const PlaneErrorFunctiond>

Definition at line 627 of file fwd.h.

◆ PlaneErrorFunctiond_const_w

using momentum::PlaneErrorFunctiond_const_w = typedef ::std::weak_ptr<const PlaneErrorFunctiond>

Definition at line 628 of file fwd.h.

◆ PlaneErrorFunctiond_p

using momentum::PlaneErrorFunctiond_p = typedef ::std::shared_ptr<PlaneErrorFunctiond>

Definition at line 623 of file fwd.h.

◆ PlaneErrorFunctiond_u

using momentum::PlaneErrorFunctiond_u = typedef ::std::unique_ptr<PlaneErrorFunctiond>

Definition at line 624 of file fwd.h.

◆ PlaneErrorFunctiond_w

using momentum::PlaneErrorFunctiond_w = typedef ::std::weak_ptr<PlaneErrorFunctiond>

Definition at line 625 of file fwd.h.

◆ PointTriangleVertexConstraint

using momentum::PointTriangleVertexConstraint = typedef PointTriangleVertexConstraintT<float>

Definition at line 141 of file fwd.h.

◆ PointTriangleVertexConstraint_const_p

using momentum::PointTriangleVertexConstraint_const_p = typedef ::std::shared_ptr<const PointTriangleVertexConstraint>

Definition at line 147 of file fwd.h.

◆ PointTriangleVertexConstraint_const_u

using momentum::PointTriangleVertexConstraint_const_u = typedef ::std::unique_ptr<const PointTriangleVertexConstraint>

Definition at line 149 of file fwd.h.

◆ PointTriangleVertexConstraint_const_w

using momentum::PointTriangleVertexConstraint_const_w = typedef ::std::weak_ptr<const PointTriangleVertexConstraint>

Definition at line 151 of file fwd.h.

◆ PointTriangleVertexConstraint_p

using momentum::PointTriangleVertexConstraint_p = typedef ::std::shared_ptr<PointTriangleVertexConstraint>

Definition at line 144 of file fwd.h.

◆ PointTriangleVertexConstraint_u

using momentum::PointTriangleVertexConstraint_u = typedef ::std::unique_ptr<PointTriangleVertexConstraint>

Definition at line 145 of file fwd.h.

◆ PointTriangleVertexConstraint_w

using momentum::PointTriangleVertexConstraint_w = typedef ::std::weak_ptr<PointTriangleVertexConstraint>

Definition at line 146 of file fwd.h.

◆ PointTriangleVertexConstraintd

using momentum::PointTriangleVertexConstraintd = typedef PointTriangleVertexConstraintT<double>

Definition at line 142 of file fwd.h.

◆ PointTriangleVertexConstraintd_const_p

using momentum::PointTriangleVertexConstraintd_const_p = typedef ::std::shared_ptr<const PointTriangleVertexConstraintd>

Definition at line 156 of file fwd.h.

◆ PointTriangleVertexConstraintd_const_u

using momentum::PointTriangleVertexConstraintd_const_u = typedef ::std::unique_ptr<const PointTriangleVertexConstraintd>

Definition at line 158 of file fwd.h.

◆ PointTriangleVertexConstraintd_const_w

using momentum::PointTriangleVertexConstraintd_const_w = typedef ::std::weak_ptr<const PointTriangleVertexConstraintd>

Definition at line 160 of file fwd.h.

◆ PointTriangleVertexConstraintd_p

using momentum::PointTriangleVertexConstraintd_p = typedef ::std::shared_ptr<PointTriangleVertexConstraintd>

Definition at line 153 of file fwd.h.

◆ PointTriangleVertexConstraintd_u

using momentum::PointTriangleVertexConstraintd_u = typedef ::std::unique_ptr<PointTriangleVertexConstraintd>

Definition at line 154 of file fwd.h.

◆ PointTriangleVertexConstraintd_w

using momentum::PointTriangleVertexConstraintd_w = typedef ::std::weak_ptr<PointTriangleVertexConstraintd>

Definition at line 155 of file fwd.h.

◆ PointTriangleVertexErrorFunction

using momentum::PointTriangleVertexErrorFunction = typedef PointTriangleVertexErrorFunctionT<float>

Definition at line 632 of file fwd.h.

◆ PointTriangleVertexErrorFunction_const_p

using momentum::PointTriangleVertexErrorFunction_const_p = typedef ::std::shared_ptr<const PointTriangleVertexErrorFunction>

Definition at line 638 of file fwd.h.

◆ PointTriangleVertexErrorFunction_const_u

using momentum::PointTriangleVertexErrorFunction_const_u = typedef ::std::unique_ptr<const PointTriangleVertexErrorFunction>

Definition at line 640 of file fwd.h.

◆ PointTriangleVertexErrorFunction_const_w

using momentum::PointTriangleVertexErrorFunction_const_w = typedef ::std::weak_ptr<const PointTriangleVertexErrorFunction>

Definition at line 642 of file fwd.h.

◆ PointTriangleVertexErrorFunction_p

using momentum::PointTriangleVertexErrorFunction_p = typedef ::std::shared_ptr<PointTriangleVertexErrorFunction>

Definition at line 635 of file fwd.h.

◆ PointTriangleVertexErrorFunction_u

using momentum::PointTriangleVertexErrorFunction_u = typedef ::std::unique_ptr<PointTriangleVertexErrorFunction>

Definition at line 636 of file fwd.h.

◆ PointTriangleVertexErrorFunction_w

using momentum::PointTriangleVertexErrorFunction_w = typedef ::std::weak_ptr<PointTriangleVertexErrorFunction>

Definition at line 637 of file fwd.h.

◆ PointTriangleVertexErrorFunctiond

using momentum::PointTriangleVertexErrorFunctiond = typedef PointTriangleVertexErrorFunctionT<double>

Definition at line 633 of file fwd.h.

◆ PointTriangleVertexErrorFunctiond_const_p

using momentum::PointTriangleVertexErrorFunctiond_const_p = typedef ::std::shared_ptr<const PointTriangleVertexErrorFunctiond>

Definition at line 648 of file fwd.h.

◆ PointTriangleVertexErrorFunctiond_const_u

using momentum::PointTriangleVertexErrorFunctiond_const_u = typedef ::std::unique_ptr<const PointTriangleVertexErrorFunctiond>

Definition at line 650 of file fwd.h.

◆ PointTriangleVertexErrorFunctiond_const_w

using momentum::PointTriangleVertexErrorFunctiond_const_w = typedef ::std::weak_ptr<const PointTriangleVertexErrorFunctiond>

Definition at line 652 of file fwd.h.

◆ PointTriangleVertexErrorFunctiond_p

using momentum::PointTriangleVertexErrorFunctiond_p = typedef ::std::shared_ptr<PointTriangleVertexErrorFunctiond>

Definition at line 645 of file fwd.h.

◆ PointTriangleVertexErrorFunctiond_u

using momentum::PointTriangleVertexErrorFunctiond_u = typedef ::std::unique_ptr<PointTriangleVertexErrorFunctiond>

Definition at line 646 of file fwd.h.

◆ PointTriangleVertexErrorFunctiond_w

using momentum::PointTriangleVertexErrorFunctiond_w = typedef ::std::weak_ptr<PointTriangleVertexErrorFunctiond>

Definition at line 647 of file fwd.h.

◆ PoseConstraints

using momentum::PoseConstraints = typedef std::unordered_map<std::string, PoseConstraint>

Definition at line 33 of file parameter_transform.h.

◆ PosePriorErrorFunction

using momentum::PosePriorErrorFunction = typedef PosePriorErrorFunctionT<float>

Definition at line 657 of file fwd.h.

◆ PosePriorErrorFunction_const_p

using momentum::PosePriorErrorFunction_const_p = typedef ::std::shared_ptr<const PosePriorErrorFunction>

Definition at line 663 of file fwd.h.

◆ PosePriorErrorFunction_const_u

using momentum::PosePriorErrorFunction_const_u = typedef ::std::unique_ptr<const PosePriorErrorFunction>

Definition at line 664 of file fwd.h.

◆ PosePriorErrorFunction_const_w

using momentum::PosePriorErrorFunction_const_w = typedef ::std::weak_ptr<const PosePriorErrorFunction>

Definition at line 665 of file fwd.h.

◆ PosePriorErrorFunction_p

using momentum::PosePriorErrorFunction_p = typedef ::std::shared_ptr<PosePriorErrorFunction>

Definition at line 660 of file fwd.h.

◆ PosePriorErrorFunction_u

using momentum::PosePriorErrorFunction_u = typedef ::std::unique_ptr<PosePriorErrorFunction>

Definition at line 661 of file fwd.h.

◆ PosePriorErrorFunction_w

using momentum::PosePriorErrorFunction_w = typedef ::std::weak_ptr<PosePriorErrorFunction>

Definition at line 662 of file fwd.h.

◆ PosePriorErrorFunctiond

using momentum::PosePriorErrorFunctiond = typedef PosePriorErrorFunctionT<double>

Definition at line 658 of file fwd.h.

◆ PosePriorErrorFunctiond_const_p

using momentum::PosePriorErrorFunctiond_const_p = typedef ::std::shared_ptr<const PosePriorErrorFunctiond>

Definition at line 670 of file fwd.h.

◆ PosePriorErrorFunctiond_const_u

using momentum::PosePriorErrorFunctiond_const_u = typedef ::std::unique_ptr<const PosePriorErrorFunctiond>

Definition at line 671 of file fwd.h.

◆ PosePriorErrorFunctiond_const_w

using momentum::PosePriorErrorFunctiond_const_w = typedef ::std::weak_ptr<const PosePriorErrorFunctiond>

Definition at line 672 of file fwd.h.

◆ PosePriorErrorFunctiond_p

using momentum::PosePriorErrorFunctiond_p = typedef ::std::shared_ptr<PosePriorErrorFunctiond>

Definition at line 667 of file fwd.h.

◆ PosePriorErrorFunctiond_u

using momentum::PosePriorErrorFunctiond_u = typedef ::std::unique_ptr<PosePriorErrorFunctiond>

Definition at line 668 of file fwd.h.

◆ PosePriorErrorFunctiond_w

using momentum::PosePriorErrorFunctiond_w = typedef ::std::weak_ptr<PosePriorErrorFunctiond>

Definition at line 669 of file fwd.h.

◆ PoseShape_const_p

using momentum::PoseShape_const_p = typedef ::std::shared_ptr<const PoseShape>

Definition at line 50 of file fwd.h.

◆ PoseShape_const_u

using momentum::PoseShape_const_u = typedef ::std::unique_ptr<const PoseShape>

Definition at line 51 of file fwd.h.

◆ PoseShape_const_w

using momentum::PoseShape_const_w = typedef ::std::weak_ptr<const PoseShape>

Definition at line 52 of file fwd.h.

◆ PoseShape_p

using momentum::PoseShape_p = typedef ::std::shared_ptr<PoseShape>

Definition at line 47 of file fwd.h.

◆ PoseShape_u

using momentum::PoseShape_u = typedef ::std::unique_ptr<PoseShape>

Definition at line 48 of file fwd.h.

◆ PoseShape_w

using momentum::PoseShape_w = typedef ::std::weak_ptr<PoseShape>

Definition at line 49 of file fwd.h.

◆ PoseTransformSolver

using momentum::PoseTransformSolver = typedef PoseTransformSolverT<float>

Definition at line 676 of file fwd.h.

◆ PoseTransformSolver_const_p

using momentum::PoseTransformSolver_const_p = typedef ::std::shared_ptr<const PoseTransformSolver>

Definition at line 682 of file fwd.h.

◆ PoseTransformSolver_const_u

using momentum::PoseTransformSolver_const_u = typedef ::std::unique_ptr<const PoseTransformSolver>

Definition at line 683 of file fwd.h.

◆ PoseTransformSolver_const_w

using momentum::PoseTransformSolver_const_w = typedef ::std::weak_ptr<const PoseTransformSolver>

Definition at line 684 of file fwd.h.

◆ PoseTransformSolver_p

using momentum::PoseTransformSolver_p = typedef ::std::shared_ptr<PoseTransformSolver>

Definition at line 679 of file fwd.h.

◆ PoseTransformSolver_u

using momentum::PoseTransformSolver_u = typedef ::std::unique_ptr<PoseTransformSolver>

Definition at line 680 of file fwd.h.

◆ PoseTransformSolver_w

using momentum::PoseTransformSolver_w = typedef ::std::weak_ptr<PoseTransformSolver>

Definition at line 681 of file fwd.h.

◆ PoseTransformSolverd

using momentum::PoseTransformSolverd = typedef PoseTransformSolverT<double>

Definition at line 677 of file fwd.h.

◆ PoseTransformSolverd_const_p

using momentum::PoseTransformSolverd_const_p = typedef ::std::shared_ptr<const PoseTransformSolverd>

Definition at line 689 of file fwd.h.

◆ PoseTransformSolverd_const_u

using momentum::PoseTransformSolverd_const_u = typedef ::std::unique_ptr<const PoseTransformSolverd>

Definition at line 690 of file fwd.h.

◆ PoseTransformSolverd_const_w

using momentum::PoseTransformSolverd_const_w = typedef ::std::weak_ptr<const PoseTransformSolverd>

Definition at line 691 of file fwd.h.

◆ PoseTransformSolverd_p

using momentum::PoseTransformSolverd_p = typedef ::std::shared_ptr<PoseTransformSolverd>

Definition at line 686 of file fwd.h.

◆ PoseTransformSolverd_u

using momentum::PoseTransformSolverd_u = typedef ::std::unique_ptr<PoseTransformSolverd>

Definition at line 687 of file fwd.h.

◆ PoseTransformSolverd_w

using momentum::PoseTransformSolverd_w = typedef ::std::weak_ptr<PoseTransformSolverd>

Definition at line 688 of file fwd.h.

◆ PositionConstraint

using momentum::PositionConstraint = typedef PositionConstraintT<float>

Definition at line 77 of file fwd.h.

◆ PositionConstraint_const_p

using momentum::PositionConstraint_const_p = typedef ::std::shared_ptr<const PositionConstraint>

Definition at line 83 of file fwd.h.

◆ PositionConstraint_const_u

using momentum::PositionConstraint_const_u = typedef ::std::unique_ptr<const PositionConstraint>

Definition at line 84 of file fwd.h.

◆ PositionConstraint_const_w

using momentum::PositionConstraint_const_w = typedef ::std::weak_ptr<const PositionConstraint>

Definition at line 85 of file fwd.h.

◆ PositionConstraint_p

using momentum::PositionConstraint_p = typedef ::std::shared_ptr<PositionConstraint>

Definition at line 80 of file fwd.h.

◆ PositionConstraint_u

using momentum::PositionConstraint_u = typedef ::std::unique_ptr<PositionConstraint>

Definition at line 81 of file fwd.h.

◆ PositionConstraint_w

using momentum::PositionConstraint_w = typedef ::std::weak_ptr<PositionConstraint>

Definition at line 82 of file fwd.h.

◆ PositionConstraintd

using momentum::PositionConstraintd = typedef PositionConstraintT<double>

Definition at line 78 of file fwd.h.

◆ PositionConstraintd_const_p

using momentum::PositionConstraintd_const_p = typedef ::std::shared_ptr<const PositionConstraintd>

Definition at line 90 of file fwd.h.

◆ PositionConstraintd_const_u

using momentum::PositionConstraintd_const_u = typedef ::std::unique_ptr<const PositionConstraintd>

Definition at line 91 of file fwd.h.

◆ PositionConstraintd_const_w

using momentum::PositionConstraintd_const_w = typedef ::std::weak_ptr<const PositionConstraintd>

Definition at line 92 of file fwd.h.

◆ PositionConstraintd_p

using momentum::PositionConstraintd_p = typedef ::std::shared_ptr<PositionConstraintd>

Definition at line 87 of file fwd.h.

◆ PositionConstraintd_u

using momentum::PositionConstraintd_u = typedef ::std::unique_ptr<PositionConstraintd>

Definition at line 88 of file fwd.h.

◆ PositionConstraintd_w

using momentum::PositionConstraintd_w = typedef ::std::weak_ptr<PositionConstraintd>

Definition at line 89 of file fwd.h.

◆ PositionConstraintState

using momentum::PositionConstraintState = typedef PositionConstraintStateT<float>

Definition at line 96 of file fwd.h.

◆ PositionConstraintState_const_p

using momentum::PositionConstraintState_const_p = typedef ::std::shared_ptr<const PositionConstraintState>

Definition at line 102 of file fwd.h.

◆ PositionConstraintState_const_u

using momentum::PositionConstraintState_const_u = typedef ::std::unique_ptr<const PositionConstraintState>

Definition at line 103 of file fwd.h.

◆ PositionConstraintState_const_w

using momentum::PositionConstraintState_const_w = typedef ::std::weak_ptr<const PositionConstraintState>

Definition at line 104 of file fwd.h.

◆ PositionConstraintState_p

using momentum::PositionConstraintState_p = typedef ::std::shared_ptr<PositionConstraintState>

Definition at line 99 of file fwd.h.

◆ PositionConstraintState_u

using momentum::PositionConstraintState_u = typedef ::std::unique_ptr<PositionConstraintState>

Definition at line 100 of file fwd.h.

◆ PositionConstraintState_w

using momentum::PositionConstraintState_w = typedef ::std::weak_ptr<PositionConstraintState>

Definition at line 101 of file fwd.h.

◆ PositionConstraintStated

using momentum::PositionConstraintStated = typedef PositionConstraintStateT<double>

Definition at line 97 of file fwd.h.

◆ PositionConstraintStated_const_p

using momentum::PositionConstraintStated_const_p = typedef ::std::shared_ptr<const PositionConstraintStated>

Definition at line 109 of file fwd.h.

◆ PositionConstraintStated_const_u

using momentum::PositionConstraintStated_const_u = typedef ::std::unique_ptr<const PositionConstraintStated>

Definition at line 110 of file fwd.h.

◆ PositionConstraintStated_const_w

using momentum::PositionConstraintStated_const_w = typedef ::std::weak_ptr<const PositionConstraintStated>

Definition at line 111 of file fwd.h.

◆ PositionConstraintStated_p

using momentum::PositionConstraintStated_p = typedef ::std::shared_ptr<PositionConstraintStated>

Definition at line 106 of file fwd.h.

◆ PositionConstraintStated_u

using momentum::PositionConstraintStated_u = typedef ::std::unique_ptr<PositionConstraintStated>

Definition at line 107 of file fwd.h.

◆ PositionConstraintStated_w

using momentum::PositionConstraintStated_w = typedef ::std::weak_ptr<PositionConstraintStated>

Definition at line 108 of file fwd.h.

◆ PositionData

using momentum::PositionData = typedef PositionDataT<float>

Definition at line 184 of file fwd.h.

◆ PositionData_const_p

using momentum::PositionData_const_p = typedef ::std::shared_ptr<const PositionData>

Definition at line 190 of file fwd.h.

◆ PositionData_const_u

using momentum::PositionData_const_u = typedef ::std::unique_ptr<const PositionData>

Definition at line 191 of file fwd.h.

◆ PositionData_const_w

using momentum::PositionData_const_w = typedef ::std::weak_ptr<const PositionData>

Definition at line 192 of file fwd.h.

◆ PositionData_p

using momentum::PositionData_p = typedef ::std::shared_ptr<PositionData>

Definition at line 187 of file fwd.h.

◆ PositionData_u

using momentum::PositionData_u = typedef ::std::unique_ptr<PositionData>

Definition at line 188 of file fwd.h.

◆ PositionData_w

using momentum::PositionData_w = typedef ::std::weak_ptr<PositionData>

Definition at line 189 of file fwd.h.

◆ PositionDatad

using momentum::PositionDatad = typedef PositionDataT<double>

Definition at line 185 of file fwd.h.

◆ PositionDatad_const_p

using momentum::PositionDatad_const_p = typedef ::std::shared_ptr<const PositionDatad>

Definition at line 197 of file fwd.h.

◆ PositionDatad_const_u

using momentum::PositionDatad_const_u = typedef ::std::unique_ptr<const PositionDatad>

Definition at line 198 of file fwd.h.

◆ PositionDatad_const_w

using momentum::PositionDatad_const_w = typedef ::std::weak_ptr<const PositionDatad>

Definition at line 199 of file fwd.h.

◆ PositionDatad_p

using momentum::PositionDatad_p = typedef ::std::shared_ptr<PositionDatad>

Definition at line 194 of file fwd.h.

◆ PositionDatad_u

using momentum::PositionDatad_u = typedef ::std::unique_ptr<PositionDatad>

Definition at line 195 of file fwd.h.

◆ PositionDatad_w

using momentum::PositionDatad_w = typedef ::std::weak_ptr<PositionDatad>

Definition at line 196 of file fwd.h.

◆ PositionErrorFunction

using momentum::PositionErrorFunction = typedef PositionErrorFunctionT<float>

Definition at line 695 of file fwd.h.

◆ PositionErrorFunction_const_p

using momentum::PositionErrorFunction_const_p = typedef ::std::shared_ptr<const PositionErrorFunction>

Definition at line 701 of file fwd.h.

◆ PositionErrorFunction_const_u

using momentum::PositionErrorFunction_const_u = typedef ::std::unique_ptr<const PositionErrorFunction>

Definition at line 702 of file fwd.h.

◆ PositionErrorFunction_const_w

using momentum::PositionErrorFunction_const_w = typedef ::std::weak_ptr<const PositionErrorFunction>

Definition at line 703 of file fwd.h.

◆ PositionErrorFunction_p

using momentum::PositionErrorFunction_p = typedef ::std::shared_ptr<PositionErrorFunction>

Definition at line 698 of file fwd.h.

◆ PositionErrorFunction_u

using momentum::PositionErrorFunction_u = typedef ::std::unique_ptr<PositionErrorFunction>

Definition at line 699 of file fwd.h.

◆ PositionErrorFunction_w

using momentum::PositionErrorFunction_w = typedef ::std::weak_ptr<PositionErrorFunction>

Definition at line 700 of file fwd.h.

◆ PositionErrorFunctiond

using momentum::PositionErrorFunctiond = typedef PositionErrorFunctionT<double>

Definition at line 696 of file fwd.h.

◆ PositionErrorFunctiond_const_p

using momentum::PositionErrorFunctiond_const_p = typedef ::std::shared_ptr<const PositionErrorFunctiond>

Definition at line 708 of file fwd.h.

◆ PositionErrorFunctiond_const_u

using momentum::PositionErrorFunctiond_const_u = typedef ::std::unique_ptr<const PositionErrorFunctiond>

Definition at line 709 of file fwd.h.

◆ PositionErrorFunctiond_const_w

using momentum::PositionErrorFunctiond_const_w = typedef ::std::weak_ptr<const PositionErrorFunctiond>

Definition at line 710 of file fwd.h.

◆ PositionErrorFunctiond_p

using momentum::PositionErrorFunctiond_p = typedef ::std::shared_ptr<PositionErrorFunctiond>

Definition at line 705 of file fwd.h.

◆ PositionErrorFunctiond_u

using momentum::PositionErrorFunctiond_u = typedef ::std::unique_ptr<PositionErrorFunctiond>

Definition at line 706 of file fwd.h.

◆ PositionErrorFunctiond_w

using momentum::PositionErrorFunctiond_w = typedef ::std::weak_ptr<PositionErrorFunctiond>

Definition at line 707 of file fwd.h.

◆ ProgressBar_const_p

using momentum::ProgressBar_const_p = typedef ::std::shared_ptr<const ProgressBar>

Definition at line 23 of file fwd.h.

◆ ProgressBar_const_u

using momentum::ProgressBar_const_u = typedef ::std::unique_ptr<const ProgressBar>

Definition at line 24 of file fwd.h.

◆ ProgressBar_const_w

using momentum::ProgressBar_const_w = typedef ::std::weak_ptr<const ProgressBar>

Definition at line 25 of file fwd.h.

◆ ProgressBar_p

using momentum::ProgressBar_p = typedef ::std::shared_ptr<ProgressBar>

Definition at line 20 of file fwd.h.

◆ ProgressBar_u

using momentum::ProgressBar_u = typedef ::std::unique_ptr<ProgressBar>

Definition at line 21 of file fwd.h.

◆ ProgressBar_w

using momentum::ProgressBar_w = typedef ::std::weak_ptr<ProgressBar>

Definition at line 22 of file fwd.h.

◆ ProjectionErrorFunction

using momentum::ProjectionErrorFunction = typedef ProjectionErrorFunctionT<float>

Definition at line 714 of file fwd.h.

◆ ProjectionErrorFunction_const_p

using momentum::ProjectionErrorFunction_const_p = typedef ::std::shared_ptr<const ProjectionErrorFunction>

Definition at line 720 of file fwd.h.

◆ ProjectionErrorFunction_const_u

using momentum::ProjectionErrorFunction_const_u = typedef ::std::unique_ptr<const ProjectionErrorFunction>

Definition at line 721 of file fwd.h.

◆ ProjectionErrorFunction_const_w

using momentum::ProjectionErrorFunction_const_w = typedef ::std::weak_ptr<const ProjectionErrorFunction>

Definition at line 722 of file fwd.h.

◆ ProjectionErrorFunction_p

using momentum::ProjectionErrorFunction_p = typedef ::std::shared_ptr<ProjectionErrorFunction>

Definition at line 717 of file fwd.h.

◆ ProjectionErrorFunction_u

using momentum::ProjectionErrorFunction_u = typedef ::std::unique_ptr<ProjectionErrorFunction>

Definition at line 718 of file fwd.h.

◆ ProjectionErrorFunction_w

using momentum::ProjectionErrorFunction_w = typedef ::std::weak_ptr<ProjectionErrorFunction>

Definition at line 719 of file fwd.h.

◆ ProjectionErrorFunctiond

using momentum::ProjectionErrorFunctiond = typedef ProjectionErrorFunctionT<double>

Definition at line 715 of file fwd.h.

◆ ProjectionErrorFunctiond_const_p

using momentum::ProjectionErrorFunctiond_const_p = typedef ::std::shared_ptr<const ProjectionErrorFunctiond>

Definition at line 727 of file fwd.h.

◆ ProjectionErrorFunctiond_const_u

using momentum::ProjectionErrorFunctiond_const_u = typedef ::std::unique_ptr<const ProjectionErrorFunctiond>

Definition at line 728 of file fwd.h.

◆ ProjectionErrorFunctiond_const_w

using momentum::ProjectionErrorFunctiond_const_w = typedef ::std::weak_ptr<const ProjectionErrorFunctiond>

Definition at line 729 of file fwd.h.

◆ ProjectionErrorFunctiond_p

using momentum::ProjectionErrorFunctiond_p = typedef ::std::shared_ptr<ProjectionErrorFunctiond>

Definition at line 724 of file fwd.h.

◆ ProjectionErrorFunctiond_u

using momentum::ProjectionErrorFunctiond_u = typedef ::std::unique_ptr<ProjectionErrorFunctiond>

Definition at line 725 of file fwd.h.

◆ ProjectionErrorFunctiond_w

using momentum::ProjectionErrorFunctiond_w = typedef ::std::weak_ptr<ProjectionErrorFunctiond>

Definition at line 726 of file fwd.h.

◆ Quaternion

template<typename T >

using momentum::Quaternion = typedef Eigen::Quaternion<T>

Definition at line 371 of file types.h.

◆ Quaterniond

using momentum::Quaterniond = typedef Quaternion<double>

Definition at line 373 of file types.h.

◆ Quaternionf

using momentum::Quaternionf = typedef Quaternion<float>

Definition at line 372 of file types.h.

◆ Ref

template<class T >

using momentum::Ref = typedef Eigen::Ref<T>

Definition at line 47 of file types.h.

◆ RowMatrix

template<typename T , int N, int M = N>

using momentum::RowMatrix = typedef Eigen::Matrix<T, N, M, Eigen::RowMajor>

Definition at line 173 of file types.h.

◆ RowMatrixX

template<typename T >

using momentum::RowMatrixX = typedef RowMatrix<T, Dynamic>

Definition at line 175 of file types.h.

◆ RowVector

template<typename T , int Dim>

using momentum::RowVector = typedef Eigen::Matrix<T, 1, Dim>

Definition at line 291 of file types.h.

◆ RowVector0

template<typename T >

using momentum::RowVector0 = typedef RowVector<T, 0>

Definition at line 303 of file types.h.

◆ RowVector0b

using momentum::RowVector0b = typedef RowVector0<std::uint8_t>

Definition at line 333 of file types.h.

◆ RowVector0d

using momentum::RowVector0d = typedef RowVector0<double>

Definition at line 325 of file types.h.

◆ RowVector0f

using momentum::RowVector0f = typedef RowVector0<float>

Definition at line 317 of file types.h.

◆ RowVector0i

using momentum::RowVector0i = typedef RowVector0<std::int32_t>

Definition at line 357 of file types.h.

◆ RowVector0s

using momentum::RowVector0s = typedef RowVector0<std::uint16_t>

Definition at line 341 of file types.h.

◆ RowVector0u

using momentum::RowVector0u = typedef RowVector0<std::uint32_t>

Definition at line 349 of file types.h.

◆ RowVector1

template<typename T >

using momentum::RowVector1 = typedef RowVector<T, 1>

Definition at line 305 of file types.h.

◆ RowVector1b

using momentum::RowVector1b = typedef RowVector1<std::uint8_t>

Definition at line 334 of file types.h.

◆ RowVector1d

using momentum::RowVector1d = typedef RowVector1<double>

Definition at line 326 of file types.h.

◆ RowVector1f

using momentum::RowVector1f = typedef RowVector1<float>

Definition at line 318 of file types.h.

◆ RowVector1i

using momentum::RowVector1i = typedef RowVector1<std::int32_t>

Definition at line 358 of file types.h.

◆ RowVector1s

using momentum::RowVector1s = typedef RowVector1<std::uint16_t>

Definition at line 342 of file types.h.

◆ RowVector1u

using momentum::RowVector1u = typedef RowVector1<std::uint32_t>

Definition at line 350 of file types.h.

◆ RowVector2

template<typename T >

using momentum::RowVector2 = typedef RowVector<T, 2>

Definition at line 307 of file types.h.

◆ RowVector2b

using momentum::RowVector2b = typedef RowVector2<std::uint8_t>

Definition at line 335 of file types.h.

◆ RowVector2d

using momentum::RowVector2d = typedef RowVector2<double>

Definition at line 327 of file types.h.

◆ RowVector2f

using momentum::RowVector2f = typedef RowVector2<float>

Definition at line 319 of file types.h.

◆ RowVector2i

using momentum::RowVector2i = typedef RowVector2<std::int32_t>

Definition at line 359 of file types.h.

◆ RowVector2s

using momentum::RowVector2s = typedef RowVector2<std::uint16_t>

Definition at line 343 of file types.h.

◆ RowVector2u

using momentum::RowVector2u = typedef RowVector2<std::uint32_t>

Definition at line 351 of file types.h.

◆ RowVector3

template<typename T >

using momentum::RowVector3 = typedef RowVector<T, 3>

Definition at line 309 of file types.h.

◆ RowVector3b

using momentum::RowVector3b = typedef RowVector3<std::uint8_t>

Definition at line 336 of file types.h.

◆ RowVector3d

using momentum::RowVector3d = typedef RowVector3<double>

Definition at line 328 of file types.h.

◆ RowVector3f

using momentum::RowVector3f = typedef RowVector3<float>

Definition at line 320 of file types.h.

◆ RowVector3i

using momentum::RowVector3i = typedef RowVector3<std::int32_t>

Definition at line 360 of file types.h.

◆ RowVector3s

using momentum::RowVector3s = typedef RowVector3<std::uint16_t>

Definition at line 344 of file types.h.

◆ RowVector3u

using momentum::RowVector3u = typedef RowVector3<std::uint32_t>

Definition at line 352 of file types.h.

◆ RowVector4

template<typename T >

using momentum::RowVector4 = typedef RowVector<T, 4>

Definition at line 311 of file types.h.

◆ RowVector4b

using momentum::RowVector4b = typedef RowVector4<std::uint8_t>

Definition at line 337 of file types.h.

◆ RowVector4d

using momentum::RowVector4d = typedef RowVector4<double>

Definition at line 329 of file types.h.

◆ RowVector4f

using momentum::RowVector4f = typedef RowVector4<float>

Definition at line 321 of file types.h.

◆ RowVector4i

using momentum::RowVector4i = typedef RowVector4<std::int32_t>

Definition at line 361 of file types.h.

◆ RowVector4s

using momentum::RowVector4s = typedef RowVector4<std::uint16_t>

Definition at line 345 of file types.h.

◆ RowVector4u

using momentum::RowVector4u = typedef RowVector4<std::uint32_t>

Definition at line 353 of file types.h.

◆ RowVector5

template<typename T >

using momentum::RowVector5 = typedef RowVector<T, 5>

Definition at line 313 of file types.h.

◆ RowVector5b

using momentum::RowVector5b = typedef RowVector5<std::uint8_t>

Definition at line 338 of file types.h.

◆ RowVector5d

using momentum::RowVector5d = typedef RowVector5<double>

Definition at line 330 of file types.h.

◆ RowVector5f

using momentum::RowVector5f = typedef RowVector5<float>

Definition at line 322 of file types.h.

◆ RowVector5i

using momentum::RowVector5i = typedef RowVector5<std::int32_t>

Definition at line 362 of file types.h.

◆ RowVector5s

using momentum::RowVector5s = typedef RowVector5<std::uint16_t>

Definition at line 346 of file types.h.

◆ RowVector5u

using momentum::RowVector5u = typedef RowVector5<std::uint32_t>

Definition at line 354 of file types.h.

◆ RowVector6

template<typename T >

using momentum::RowVector6 = typedef RowVector<T, 6>

Definition at line 315 of file types.h.

◆ RowVector6b

using momentum::RowVector6b = typedef RowVector6<std::uint8_t>

Definition at line 339 of file types.h.

◆ RowVector6d

using momentum::RowVector6d = typedef RowVector6<double>

Definition at line 331 of file types.h.

◆ RowVector6f

using momentum::RowVector6f = typedef RowVector6<float>

Definition at line 323 of file types.h.

◆ RowVector6i

using momentum::RowVector6i = typedef RowVector6<std::int32_t>

Definition at line 363 of file types.h.

◆ RowVector6s

using momentum::RowVector6s = typedef RowVector6<std::uint16_t>

Definition at line 347 of file types.h.

◆ RowVector6u

using momentum::RowVector6u = typedef RowVector6<std::uint32_t>

Definition at line 355 of file types.h.

◆ RowVectorX

template<typename T >

using momentum::RowVectorX = typedef RowVector<T, Dynamic>

Definition at line 293 of file types.h.

◆ RowVectorXb

using momentum::RowVectorXb = typedef RowVectorX<std::uint8_t>

Definition at line 297 of file types.h.

◆ RowVectorXd

using momentum::RowVectorXd = typedef RowVectorX<double>

Definition at line 296 of file types.h.

◆ RowVectorXf

using momentum::RowVectorXf = typedef RowVectorX<float>

Definition at line 295 of file types.h.

◆ RowVectorXi

using momentum::RowVectorXi = typedef RowVectorX<std::int32_t>

Definition at line 300 of file types.h.

◆ RowVectorXs

using momentum::RowVectorXs = typedef RowVectorX<std::uint16_t>

Definition at line 298 of file types.h.

◆ RowVectorXu

using momentum::RowVectorXu = typedef RowVectorX<std::uint32_t>

Definition at line 299 of file types.h.

◆ SequenceErrorFunction

using momentum::SequenceErrorFunction = typedef SequenceErrorFunctionT<float>

Definition at line 38 of file fwd.h.

◆ SequenceErrorFunction_const_p

using momentum::SequenceErrorFunction_const_p = typedef ::std::shared_ptr<const SequenceErrorFunction>

Definition at line 44 of file fwd.h.

◆ SequenceErrorFunction_const_u

using momentum::SequenceErrorFunction_const_u = typedef ::std::unique_ptr<const SequenceErrorFunction>

Definition at line 45 of file fwd.h.

◆ SequenceErrorFunction_const_w

using momentum::SequenceErrorFunction_const_w = typedef ::std::weak_ptr<const SequenceErrorFunction>

Definition at line 46 of file fwd.h.

◆ SequenceErrorFunction_p

using momentum::SequenceErrorFunction_p = typedef ::std::shared_ptr<SequenceErrorFunction>

Definition at line 41 of file fwd.h.

◆ SequenceErrorFunction_u

using momentum::SequenceErrorFunction_u = typedef ::std::unique_ptr<SequenceErrorFunction>

Definition at line 42 of file fwd.h.

◆ SequenceErrorFunction_w

using momentum::SequenceErrorFunction_w = typedef ::std::weak_ptr<SequenceErrorFunction>

Definition at line 43 of file fwd.h.

◆ SequenceErrorFunctiond

using momentum::SequenceErrorFunctiond = typedef SequenceErrorFunctionT<double>

Definition at line 39 of file fwd.h.

◆ SequenceErrorFunctiond_const_p

using momentum::SequenceErrorFunctiond_const_p = typedef ::std::shared_ptr<const SequenceErrorFunctiond>

Definition at line 51 of file fwd.h.

◆ SequenceErrorFunctiond_const_u

using momentum::SequenceErrorFunctiond_const_u = typedef ::std::unique_ptr<const SequenceErrorFunctiond>

Definition at line 52 of file fwd.h.

◆ SequenceErrorFunctiond_const_w

using momentum::SequenceErrorFunctiond_const_w = typedef ::std::weak_ptr<const SequenceErrorFunctiond>

Definition at line 53 of file fwd.h.

◆ SequenceErrorFunctiond_p

using momentum::SequenceErrorFunctiond_p = typedef ::std::shared_ptr<SequenceErrorFunctiond>

Definition at line 48 of file fwd.h.

◆ SequenceErrorFunctiond_u

using momentum::SequenceErrorFunctiond_u = typedef ::std::unique_ptr<SequenceErrorFunctiond>

Definition at line 49 of file fwd.h.

◆ SequenceErrorFunctiond_w

using momentum::SequenceErrorFunctiond_w = typedef ::std::weak_ptr<SequenceErrorFunctiond>

Definition at line 50 of file fwd.h.

◆ SequenceSolver

using momentum::SequenceSolver = typedef SequenceSolverT<float>

Definition at line 126 of file fwd.h.

◆ SequenceSolver_const_p

using momentum::SequenceSolver_const_p = typedef ::std::shared_ptr<const SequenceSolver>

Definition at line 132 of file fwd.h.

◆ SequenceSolver_const_u

using momentum::SequenceSolver_const_u = typedef ::std::unique_ptr<const SequenceSolver>

Definition at line 133 of file fwd.h.

◆ SequenceSolver_const_w

using momentum::SequenceSolver_const_w = typedef ::std::weak_ptr<const SequenceSolver>

Definition at line 134 of file fwd.h.

◆ SequenceSolver_p

using momentum::SequenceSolver_p = typedef ::std::shared_ptr<SequenceSolver>

Definition at line 129 of file fwd.h.

◆ SequenceSolver_u

using momentum::SequenceSolver_u = typedef ::std::unique_ptr<SequenceSolver>

Definition at line 130 of file fwd.h.

◆ SequenceSolver_w

using momentum::SequenceSolver_w = typedef ::std::weak_ptr<SequenceSolver>

Definition at line 131 of file fwd.h.

◆ SequenceSolverd

using momentum::SequenceSolverd = typedef SequenceSolverT<double>

Definition at line 127 of file fwd.h.

◆ SequenceSolverd_const_p

using momentum::SequenceSolverd_const_p = typedef ::std::shared_ptr<const SequenceSolverd>

Definition at line 139 of file fwd.h.

◆ SequenceSolverd_const_u

using momentum::SequenceSolverd_const_u = typedef ::std::unique_ptr<const SequenceSolverd>

Definition at line 140 of file fwd.h.

◆ SequenceSolverd_const_w

using momentum::SequenceSolverd_const_w = typedef ::std::weak_ptr<const SequenceSolverd>

Definition at line 141 of file fwd.h.

◆ SequenceSolverd_p

using momentum::SequenceSolverd_p = typedef ::std::shared_ptr<SequenceSolverd>

Definition at line 136 of file fwd.h.

◆ SequenceSolverd_u

using momentum::SequenceSolverd_u = typedef ::std::unique_ptr<SequenceSolverd>

Definition at line 137 of file fwd.h.

◆ SequenceSolverd_w

using momentum::SequenceSolverd_w = typedef ::std::weak_ptr<SequenceSolverd>

Definition at line 138 of file fwd.h.

◆ SequenceSolverFunction

using momentum::SequenceSolverFunction = typedef SequenceSolverFunctionT<float>

Definition at line 145 of file fwd.h.

◆ SequenceSolverFunction_const_p

using momentum::SequenceSolverFunction_const_p = typedef ::std::shared_ptr<const SequenceSolverFunction>

Definition at line 151 of file fwd.h.

◆ SequenceSolverFunction_const_u

using momentum::SequenceSolverFunction_const_u = typedef ::std::unique_ptr<const SequenceSolverFunction>

Definition at line 152 of file fwd.h.

◆ SequenceSolverFunction_const_w

using momentum::SequenceSolverFunction_const_w = typedef ::std::weak_ptr<const SequenceSolverFunction>

Definition at line 153 of file fwd.h.

◆ SequenceSolverFunction_p

using momentum::SequenceSolverFunction_p = typedef ::std::shared_ptr<SequenceSolverFunction>

Definition at line 148 of file fwd.h.

◆ SequenceSolverFunction_u

using momentum::SequenceSolverFunction_u = typedef ::std::unique_ptr<SequenceSolverFunction>

Definition at line 149 of file fwd.h.

◆ SequenceSolverFunction_w

using momentum::SequenceSolverFunction_w = typedef ::std::weak_ptr<SequenceSolverFunction>

Definition at line 150 of file fwd.h.

◆ SequenceSolverFunctiond

using momentum::SequenceSolverFunctiond = typedef SequenceSolverFunctionT<double>

Definition at line 146 of file fwd.h.

◆ SequenceSolverFunctiond_const_p

using momentum::SequenceSolverFunctiond_const_p = typedef ::std::shared_ptr<const SequenceSolverFunctiond>

Definition at line 158 of file fwd.h.

◆ SequenceSolverFunctiond_const_u

using momentum::SequenceSolverFunctiond_const_u = typedef ::std::unique_ptr<const SequenceSolverFunctiond>

Definition at line 159 of file fwd.h.

◆ SequenceSolverFunctiond_const_w

using momentum::SequenceSolverFunctiond_const_w = typedef ::std::weak_ptr<const SequenceSolverFunctiond>

Definition at line 160 of file fwd.h.

◆ SequenceSolverFunctiond_p

using momentum::SequenceSolverFunctiond_p = typedef ::std::shared_ptr<SequenceSolverFunctiond>

Definition at line 155 of file fwd.h.

◆ SequenceSolverFunctiond_u

using momentum::SequenceSolverFunctiond_u = typedef ::std::unique_ptr<SequenceSolverFunctiond>

Definition at line 156 of file fwd.h.

◆ SequenceSolverFunctiond_w

using momentum::SequenceSolverFunctiond_w = typedef ::std::weak_ptr<SequenceSolverFunctiond>

Definition at line 157 of file fwd.h.

◆ SequenceSolverOptions_const_p

using momentum::SequenceSolverOptions_const_p = typedef ::std::shared_ptr<const SequenceSolverOptions>

Definition at line 32 of file fwd.h.

◆ SequenceSolverOptions_const_u

using momentum::SequenceSolverOptions_const_u = typedef ::std::unique_ptr<const SequenceSolverOptions>

Definition at line 33 of file fwd.h.

◆ SequenceSolverOptions_const_w

using momentum::SequenceSolverOptions_const_w = typedef ::std::weak_ptr<const SequenceSolverOptions>

Definition at line 34 of file fwd.h.

◆ SequenceSolverOptions_p

using momentum::SequenceSolverOptions_p = typedef ::std::shared_ptr<SequenceSolverOptions>

Definition at line 29 of file fwd.h.

◆ SequenceSolverOptions_u

using momentum::SequenceSolverOptions_u = typedef ::std::unique_ptr<SequenceSolverOptions>

Definition at line 30 of file fwd.h.

◆ SequenceSolverOptions_w

using momentum::SequenceSolverOptions_w = typedef ::std::weak_ptr<SequenceSolverOptions>

Definition at line 31 of file fwd.h.

◆ SimdCollisionErrorFunction

using momentum::SimdCollisionErrorFunction = typedef SimdCollisionErrorFunctionT<float>

Definition at line 733 of file fwd.h.

◆ SimdCollisionErrorFunction_const_p

using momentum::SimdCollisionErrorFunction_const_p = typedef ::std::shared_ptr<const SimdCollisionErrorFunction>

Definition at line 739 of file fwd.h.

◆ SimdCollisionErrorFunction_const_u

using momentum::SimdCollisionErrorFunction_const_u = typedef ::std::unique_ptr<const SimdCollisionErrorFunction>

Definition at line 740 of file fwd.h.

◆ SimdCollisionErrorFunction_const_w

using momentum::SimdCollisionErrorFunction_const_w = typedef ::std::weak_ptr<const SimdCollisionErrorFunction>

Definition at line 741 of file fwd.h.

◆ SimdCollisionErrorFunction_p

using momentum::SimdCollisionErrorFunction_p = typedef ::std::shared_ptr<SimdCollisionErrorFunction>

Definition at line 736 of file fwd.h.

◆ SimdCollisionErrorFunction_u

using momentum::SimdCollisionErrorFunction_u = typedef ::std::unique_ptr<SimdCollisionErrorFunction>

Definition at line 737 of file fwd.h.

◆ SimdCollisionErrorFunction_w

using momentum::SimdCollisionErrorFunction_w = typedef ::std::weak_ptr<SimdCollisionErrorFunction>

Definition at line 738 of file fwd.h.

◆ SimdCollisionErrorFunctiond

using momentum::SimdCollisionErrorFunctiond = typedef SimdCollisionErrorFunctionT<double>

Definition at line 734 of file fwd.h.

◆ SimdCollisionErrorFunctiond_const_p

using momentum::SimdCollisionErrorFunctiond_const_p = typedef ::std::shared_ptr<const SimdCollisionErrorFunctiond>

Definition at line 746 of file fwd.h.

◆ SimdCollisionErrorFunctiond_const_u

using momentum::SimdCollisionErrorFunctiond_const_u = typedef ::std::unique_ptr<const SimdCollisionErrorFunctiond>

Definition at line 747 of file fwd.h.

◆ SimdCollisionErrorFunctiond_const_w

using momentum::SimdCollisionErrorFunctiond_const_w = typedef ::std::weak_ptr<const SimdCollisionErrorFunctiond>

Definition at line 748 of file fwd.h.

◆ SimdCollisionErrorFunctiond_p

using momentum::SimdCollisionErrorFunctiond_p = typedef ::std::shared_ptr<SimdCollisionErrorFunctiond>

Definition at line 743 of file fwd.h.

◆ SimdCollisionErrorFunctiond_u

using momentum::SimdCollisionErrorFunctiond_u = typedef ::std::unique_ptr<SimdCollisionErrorFunctiond>

Definition at line 744 of file fwd.h.

◆ SimdCollisionErrorFunctiond_w

using momentum::SimdCollisionErrorFunctiond_w = typedef ::std::weak_ptr<SimdCollisionErrorFunctiond>

Definition at line 745 of file fwd.h.

◆ SimdGeneralizedLoss

using momentum::SimdGeneralizedLoss = typedef SimdGeneralizedLossT<float>

Definition at line 115 of file fwd.h.

◆ SimdGeneralizedLoss_const_p

using momentum::SimdGeneralizedLoss_const_p = typedef ::std::shared_ptr<const SimdGeneralizedLoss>

Definition at line 121 of file fwd.h.

◆ SimdGeneralizedLoss_const_u

using momentum::SimdGeneralizedLoss_const_u = typedef ::std::unique_ptr<const SimdGeneralizedLoss>

Definition at line 122 of file fwd.h.

◆ SimdGeneralizedLoss_const_w

using momentum::SimdGeneralizedLoss_const_w = typedef ::std::weak_ptr<const SimdGeneralizedLoss>

Definition at line 123 of file fwd.h.

◆ SimdGeneralizedLoss_p

using momentum::SimdGeneralizedLoss_p = typedef ::std::shared_ptr<SimdGeneralizedLoss>

Definition at line 118 of file fwd.h.

◆ SimdGeneralizedLoss_u

using momentum::SimdGeneralizedLoss_u = typedef ::std::unique_ptr<SimdGeneralizedLoss>

Definition at line 119 of file fwd.h.

◆ SimdGeneralizedLoss_w

using momentum::SimdGeneralizedLoss_w = typedef ::std::weak_ptr<SimdGeneralizedLoss>

Definition at line 120 of file fwd.h.

◆ SimdGeneralizedLossd

using momentum::SimdGeneralizedLossd = typedef SimdGeneralizedLossT<double>

Definition at line 116 of file fwd.h.

◆ SimdGeneralizedLossd_const_p

using momentum::SimdGeneralizedLossd_const_p = typedef ::std::shared_ptr<const SimdGeneralizedLossd>

Definition at line 128 of file fwd.h.

◆ SimdGeneralizedLossd_const_u

using momentum::SimdGeneralizedLossd_const_u = typedef ::std::unique_ptr<const SimdGeneralizedLossd>

Definition at line 129 of file fwd.h.

◆ SimdGeneralizedLossd_const_w

using momentum::SimdGeneralizedLossd_const_w = typedef ::std::weak_ptr<const SimdGeneralizedLossd>

Definition at line 130 of file fwd.h.

◆ SimdGeneralizedLossd_p

using momentum::SimdGeneralizedLossd_p = typedef ::std::shared_ptr<SimdGeneralizedLossd>

Definition at line 125 of file fwd.h.

◆ SimdGeneralizedLossd_u

using momentum::SimdGeneralizedLossd_u = typedef ::std::unique_ptr<SimdGeneralizedLossd>

Definition at line 126 of file fwd.h.

◆ SimdGeneralizedLossd_w

using momentum::SimdGeneralizedLossd_w = typedef ::std::weak_ptr<SimdGeneralizedLossd>

Definition at line 127 of file fwd.h.

◆ SimdNormalConstraints_const_p

using momentum::SimdNormalConstraints_const_p = typedef ::std::shared_ptr<const SimdNormalConstraints>

Definition at line 41 of file fwd.h.

◆ SimdNormalConstraints_const_u

using momentum::SimdNormalConstraints_const_u = typedef ::std::unique_ptr<const SimdNormalConstraints>

Definition at line 42 of file fwd.h.

◆ SimdNormalConstraints_const_w

using momentum::SimdNormalConstraints_const_w = typedef ::std::weak_ptr<const SimdNormalConstraints>

Definition at line 43 of file fwd.h.

◆ SimdNormalConstraints_p

using momentum::SimdNormalConstraints_p = typedef ::std::shared_ptr<SimdNormalConstraints>

Definition at line 38 of file fwd.h.

◆ SimdNormalConstraints_u

using momentum::SimdNormalConstraints_u = typedef ::std::unique_ptr<SimdNormalConstraints>

Definition at line 39 of file fwd.h.

◆ SimdNormalConstraints_w

using momentum::SimdNormalConstraints_w = typedef ::std::weak_ptr<SimdNormalConstraints>

Definition at line 40 of file fwd.h.

◆ SimdNormalErrorFunction_const_p

using momentum::SimdNormalErrorFunction_const_p = typedef ::std::shared_ptr<const SimdNormalErrorFunction>

Definition at line 288 of file fwd.h.

◆ SimdNormalErrorFunction_const_u

using momentum::SimdNormalErrorFunction_const_u = typedef ::std::unique_ptr<const SimdNormalErrorFunction>

Definition at line 289 of file fwd.h.

◆ SimdNormalErrorFunction_const_w

using momentum::SimdNormalErrorFunction_const_w = typedef ::std::weak_ptr<const SimdNormalErrorFunction>

Definition at line 290 of file fwd.h.

◆ SimdNormalErrorFunction_p

using momentum::SimdNormalErrorFunction_p = typedef ::std::shared_ptr<SimdNormalErrorFunction>

Definition at line 285 of file fwd.h.

◆ SimdNormalErrorFunction_u

using momentum::SimdNormalErrorFunction_u = typedef ::std::unique_ptr<SimdNormalErrorFunction>

Definition at line 286 of file fwd.h.

◆ SimdNormalErrorFunction_w

using momentum::SimdNormalErrorFunction_w = typedef ::std::weak_ptr<SimdNormalErrorFunction>

Definition at line 287 of file fwd.h.

◆ SimdNormalErrorFunctionAVX_const_p

using momentum::SimdNormalErrorFunctionAVX_const_p = typedef ::std::shared_ptr<const SimdNormalErrorFunctionAVX>

Definition at line 315 of file fwd.h.

◆ SimdNormalErrorFunctionAVX_const_u

using momentum::SimdNormalErrorFunctionAVX_const_u = typedef ::std::unique_ptr<const SimdNormalErrorFunctionAVX>

Definition at line 316 of file fwd.h.

◆ SimdNormalErrorFunctionAVX_const_w

using momentum::SimdNormalErrorFunctionAVX_const_w = typedef ::std::weak_ptr<const SimdNormalErrorFunctionAVX>

Definition at line 317 of file fwd.h.

◆ SimdNormalErrorFunctionAVX_p

using momentum::SimdNormalErrorFunctionAVX_p = typedef ::std::shared_ptr<SimdNormalErrorFunctionAVX>

Definition at line 312 of file fwd.h.

◆ SimdNormalErrorFunctionAVX_u

using momentum::SimdNormalErrorFunctionAVX_u = typedef ::std::unique_ptr<SimdNormalErrorFunctionAVX>

Definition at line 313 of file fwd.h.

◆ SimdNormalErrorFunctionAVX_w

using momentum::SimdNormalErrorFunctionAVX_w = typedef ::std::weak_ptr<SimdNormalErrorFunctionAVX>

Definition at line 314 of file fwd.h.

◆ SimdPlaneConstraints_const_p

using momentum::SimdPlaneConstraints_const_p = typedef ::std::shared_ptr<const SimdPlaneConstraints>

Definition at line 50 of file fwd.h.

◆ SimdPlaneConstraints_const_u

using momentum::SimdPlaneConstraints_const_u = typedef ::std::unique_ptr<const SimdPlaneConstraints>

Definition at line 51 of file fwd.h.

◆ SimdPlaneConstraints_const_w

using momentum::SimdPlaneConstraints_const_w = typedef ::std::weak_ptr<const SimdPlaneConstraints>

Definition at line 52 of file fwd.h.

◆ SimdPlaneConstraints_p

using momentum::SimdPlaneConstraints_p = typedef ::std::shared_ptr<SimdPlaneConstraints>

Definition at line 47 of file fwd.h.

◆ SimdPlaneConstraints_u

using momentum::SimdPlaneConstraints_u = typedef ::std::unique_ptr<SimdPlaneConstraints>

Definition at line 48 of file fwd.h.

◆ SimdPlaneConstraints_w

using momentum::SimdPlaneConstraints_w = typedef ::std::weak_ptr<SimdPlaneConstraints>

Definition at line 49 of file fwd.h.

◆ SimdPlaneErrorFunction_const_p

using momentum::SimdPlaneErrorFunction_const_p = typedef ::std::shared_ptr<const SimdPlaneErrorFunction>

Definition at line 297 of file fwd.h.

◆ SimdPlaneErrorFunction_const_u

using momentum::SimdPlaneErrorFunction_const_u = typedef ::std::unique_ptr<const SimdPlaneErrorFunction>

Definition at line 298 of file fwd.h.

◆ SimdPlaneErrorFunction_const_w

using momentum::SimdPlaneErrorFunction_const_w = typedef ::std::weak_ptr<const SimdPlaneErrorFunction>

Definition at line 299 of file fwd.h.

◆ SimdPlaneErrorFunction_p

using momentum::SimdPlaneErrorFunction_p = typedef ::std::shared_ptr<SimdPlaneErrorFunction>

Definition at line 294 of file fwd.h.

◆ SimdPlaneErrorFunction_u

using momentum::SimdPlaneErrorFunction_u = typedef ::std::unique_ptr<SimdPlaneErrorFunction>

Definition at line 295 of file fwd.h.

◆ SimdPlaneErrorFunction_w

using momentum::SimdPlaneErrorFunction_w = typedef ::std::weak_ptr<SimdPlaneErrorFunction>

Definition at line 296 of file fwd.h.

◆ SimdPlaneErrorFunctionAVX_const_p

using momentum::SimdPlaneErrorFunctionAVX_const_p = typedef ::std::shared_ptr<const SimdPlaneErrorFunctionAVX>

Definition at line 324 of file fwd.h.

◆ SimdPlaneErrorFunctionAVX_const_u

using momentum::SimdPlaneErrorFunctionAVX_const_u = typedef ::std::unique_ptr<const SimdPlaneErrorFunctionAVX>

Definition at line 325 of file fwd.h.

◆ SimdPlaneErrorFunctionAVX_const_w

using momentum::SimdPlaneErrorFunctionAVX_const_w = typedef ::std::weak_ptr<const SimdPlaneErrorFunctionAVX>

Definition at line 326 of file fwd.h.

◆ SimdPlaneErrorFunctionAVX_p

using momentum::SimdPlaneErrorFunctionAVX_p = typedef ::std::shared_ptr<SimdPlaneErrorFunctionAVX>

Definition at line 321 of file fwd.h.

◆ SimdPlaneErrorFunctionAVX_u

using momentum::SimdPlaneErrorFunctionAVX_u = typedef ::std::unique_ptr<SimdPlaneErrorFunctionAVX>

Definition at line 322 of file fwd.h.

◆ SimdPlaneErrorFunctionAVX_w

using momentum::SimdPlaneErrorFunctionAVX_w = typedef ::std::weak_ptr<SimdPlaneErrorFunctionAVX>

Definition at line 323 of file fwd.h.

◆ SimdPositionConstraints_const_p

using momentum::SimdPositionConstraints_const_p = typedef ::std::shared_ptr<const SimdPositionConstraints>

Definition at line 59 of file fwd.h.

◆ SimdPositionConstraints_const_u

using momentum::SimdPositionConstraints_const_u = typedef ::std::unique_ptr<const SimdPositionConstraints>

Definition at line 60 of file fwd.h.

◆ SimdPositionConstraints_const_w

using momentum::SimdPositionConstraints_const_w = typedef ::std::weak_ptr<const SimdPositionConstraints>

Definition at line 61 of file fwd.h.

◆ SimdPositionConstraints_p

using momentum::SimdPositionConstraints_p = typedef ::std::shared_ptr<SimdPositionConstraints>

Definition at line 56 of file fwd.h.

◆ SimdPositionConstraints_u

using momentum::SimdPositionConstraints_u = typedef ::std::unique_ptr<SimdPositionConstraints>

Definition at line 57 of file fwd.h.

◆ SimdPositionConstraints_w

using momentum::SimdPositionConstraints_w = typedef ::std::weak_ptr<SimdPositionConstraints>

Definition at line 58 of file fwd.h.

◆ SimdPositionErrorFunction_const_p

using momentum::SimdPositionErrorFunction_const_p = typedef ::std::shared_ptr<const SimdPositionErrorFunction>

Definition at line 306 of file fwd.h.

◆ SimdPositionErrorFunction_const_u

using momentum::SimdPositionErrorFunction_const_u = typedef ::std::unique_ptr<const SimdPositionErrorFunction>

Definition at line 307 of file fwd.h.

◆ SimdPositionErrorFunction_const_w

using momentum::SimdPositionErrorFunction_const_w = typedef ::std::weak_ptr<const SimdPositionErrorFunction>

Definition at line 308 of file fwd.h.

◆ SimdPositionErrorFunction_p

using momentum::SimdPositionErrorFunction_p = typedef ::std::shared_ptr<SimdPositionErrorFunction>

Definition at line 303 of file fwd.h.

◆ SimdPositionErrorFunction_u

using momentum::SimdPositionErrorFunction_u = typedef ::std::unique_ptr<SimdPositionErrorFunction>

Definition at line 304 of file fwd.h.

◆ SimdPositionErrorFunction_w

using momentum::SimdPositionErrorFunction_w = typedef ::std::weak_ptr<SimdPositionErrorFunction>

Definition at line 305 of file fwd.h.

◆ SimdPositionErrorFunctionAVX_const_p

using momentum::SimdPositionErrorFunctionAVX_const_p = typedef ::std::shared_ptr<const SimdPositionErrorFunctionAVX>

Definition at line 333 of file fwd.h.

◆ SimdPositionErrorFunctionAVX_const_u

using momentum::SimdPositionErrorFunctionAVX_const_u = typedef ::std::unique_ptr<const SimdPositionErrorFunctionAVX>

Definition at line 334 of file fwd.h.

◆ SimdPositionErrorFunctionAVX_const_w

using momentum::SimdPositionErrorFunctionAVX_const_w = typedef ::std::weak_ptr<const SimdPositionErrorFunctionAVX>

Definition at line 335 of file fwd.h.

◆ SimdPositionErrorFunctionAVX_p

using momentum::SimdPositionErrorFunctionAVX_p = typedef ::std::shared_ptr<SimdPositionErrorFunctionAVX>

Definition at line 330 of file fwd.h.

◆ SimdPositionErrorFunctionAVX_u

using momentum::SimdPositionErrorFunctionAVX_u = typedef ::std::unique_ptr<SimdPositionErrorFunctionAVX>

Definition at line 331 of file fwd.h.

◆ SimdPositionErrorFunctionAVX_w

using momentum::SimdPositionErrorFunctionAVX_w = typedef ::std::weak_ptr<SimdPositionErrorFunctionAVX>

Definition at line 332 of file fwd.h.

◆ Skeleton

using momentum::Skeleton = typedef SkeletonT<float>

Definition at line 188 of file fwd.h.

◆ Skeleton_const_p

using momentum::Skeleton_const_p = typedef ::std::shared_ptr<const Skeleton>

Definition at line 194 of file fwd.h.

◆ Skeleton_const_u

using momentum::Skeleton_const_u = typedef ::std::unique_ptr<const Skeleton>

Definition at line 195 of file fwd.h.

◆ Skeleton_const_w

using momentum::Skeleton_const_w = typedef ::std::weak_ptr<const Skeleton>

Definition at line 196 of file fwd.h.

◆ Skeleton_p

using momentum::Skeleton_p = typedef ::std::shared_ptr<Skeleton>

Definition at line 191 of file fwd.h.

◆ Skeleton_u

using momentum::Skeleton_u = typedef ::std::unique_ptr<Skeleton>

Definition at line 192 of file fwd.h.

◆ Skeleton_w

using momentum::Skeleton_w = typedef ::std::weak_ptr<Skeleton>

Definition at line 193 of file fwd.h.

◆ Skeletond

using momentum::Skeletond = typedef SkeletonT<double>

Definition at line 189 of file fwd.h.

◆ Skeletond_const_p

using momentum::Skeletond_const_p = typedef ::std::shared_ptr<const Skeletond>

Definition at line 201 of file fwd.h.

◆ Skeletond_const_u

using momentum::Skeletond_const_u = typedef ::std::unique_ptr<const Skeletond>

Definition at line 202 of file fwd.h.

◆ Skeletond_const_w

using momentum::Skeletond_const_w = typedef ::std::weak_ptr<const Skeletond>

Definition at line 203 of file fwd.h.

◆ Skeletond_p

using momentum::Skeletond_p = typedef ::std::shared_ptr<Skeletond>

Definition at line 198 of file fwd.h.

◆ Skeletond_u

using momentum::Skeletond_u = typedef ::std::unique_ptr<Skeletond>

Definition at line 199 of file fwd.h.

◆ Skeletond_w

using momentum::Skeletond_w = typedef ::std::weak_ptr<Skeletond>

Definition at line 200 of file fwd.h.

◆ SkeletonErrorFunction

using momentum::SkeletonErrorFunction = typedef SkeletonErrorFunctionT<float>

Definition at line 752 of file fwd.h.

◆ SkeletonErrorFunction_const_p

using momentum::SkeletonErrorFunction_const_p = typedef ::std::shared_ptr<const SkeletonErrorFunction>

Definition at line 758 of file fwd.h.

◆ SkeletonErrorFunction_const_u

using momentum::SkeletonErrorFunction_const_u = typedef ::std::unique_ptr<const SkeletonErrorFunction>

Definition at line 759 of file fwd.h.

◆ SkeletonErrorFunction_const_w

using momentum::SkeletonErrorFunction_const_w = typedef ::std::weak_ptr<const SkeletonErrorFunction>

Definition at line 760 of file fwd.h.

◆ SkeletonErrorFunction_p

using momentum::SkeletonErrorFunction_p = typedef ::std::shared_ptr<SkeletonErrorFunction>

Definition at line 755 of file fwd.h.

◆ SkeletonErrorFunction_u

using momentum::SkeletonErrorFunction_u = typedef ::std::unique_ptr<SkeletonErrorFunction>

Definition at line 756 of file fwd.h.

◆ SkeletonErrorFunction_w

using momentum::SkeletonErrorFunction_w = typedef ::std::weak_ptr<SkeletonErrorFunction>

Definition at line 757 of file fwd.h.

◆ SkeletonErrorFunctiond

using momentum::SkeletonErrorFunctiond = typedef SkeletonErrorFunctionT<double>

Definition at line 753 of file fwd.h.

◆ SkeletonErrorFunctiond_const_p

using momentum::SkeletonErrorFunctiond_const_p = typedef ::std::shared_ptr<const SkeletonErrorFunctiond>

Definition at line 765 of file fwd.h.

◆ SkeletonErrorFunctiond_const_u

using momentum::SkeletonErrorFunctiond_const_u = typedef ::std::unique_ptr<const SkeletonErrorFunctiond>

Definition at line 766 of file fwd.h.

◆ SkeletonErrorFunctiond_const_w

using momentum::SkeletonErrorFunctiond_const_w = typedef ::std::weak_ptr<const SkeletonErrorFunctiond>

Definition at line 767 of file fwd.h.

◆ SkeletonErrorFunctiond_p

using momentum::SkeletonErrorFunctiond_p = typedef ::std::shared_ptr<SkeletonErrorFunctiond>

Definition at line 762 of file fwd.h.

◆ SkeletonErrorFunctiond_u

using momentum::SkeletonErrorFunctiond_u = typedef ::std::unique_ptr<SkeletonErrorFunctiond>

Definition at line 763 of file fwd.h.

◆ SkeletonErrorFunctiond_w

using momentum::SkeletonErrorFunctiond_w = typedef ::std::weak_ptr<SkeletonErrorFunctiond>

Definition at line 764 of file fwd.h.

◆ SkeletonSolverFunction

using momentum::SkeletonSolverFunction = typedef SkeletonSolverFunctionT<float>

Definition at line 771 of file fwd.h.

◆ SkeletonSolverFunction_const_p

using momentum::SkeletonSolverFunction_const_p = typedef ::std::shared_ptr<const SkeletonSolverFunction>

Definition at line 777 of file fwd.h.

◆ SkeletonSolverFunction_const_u

using momentum::SkeletonSolverFunction_const_u = typedef ::std::unique_ptr<const SkeletonSolverFunction>

Definition at line 778 of file fwd.h.

◆ SkeletonSolverFunction_const_w

using momentum::SkeletonSolverFunction_const_w = typedef ::std::weak_ptr<const SkeletonSolverFunction>

Definition at line 779 of file fwd.h.

◆ SkeletonSolverFunction_p

using momentum::SkeletonSolverFunction_p = typedef ::std::shared_ptr<SkeletonSolverFunction>

Definition at line 774 of file fwd.h.

◆ SkeletonSolverFunction_u

using momentum::SkeletonSolverFunction_u = typedef ::std::unique_ptr<SkeletonSolverFunction>

Definition at line 775 of file fwd.h.

◆ SkeletonSolverFunction_w

using momentum::SkeletonSolverFunction_w = typedef ::std::weak_ptr<SkeletonSolverFunction>

Definition at line 776 of file fwd.h.

◆ SkeletonSolverFunctiond

using momentum::SkeletonSolverFunctiond = typedef SkeletonSolverFunctionT<double>

Definition at line 772 of file fwd.h.

◆ SkeletonSolverFunctiond_const_p

using momentum::SkeletonSolverFunctiond_const_p = typedef ::std::shared_ptr<const SkeletonSolverFunctiond>

Definition at line 784 of file fwd.h.

◆ SkeletonSolverFunctiond_const_u

using momentum::SkeletonSolverFunctiond_const_u = typedef ::std::unique_ptr<const SkeletonSolverFunctiond>

Definition at line 785 of file fwd.h.

◆ SkeletonSolverFunctiond_const_w

using momentum::SkeletonSolverFunctiond_const_w = typedef ::std::weak_ptr<const SkeletonSolverFunctiond>

Definition at line 786 of file fwd.h.

◆ SkeletonSolverFunctiond_p

using momentum::SkeletonSolverFunctiond_p = typedef ::std::shared_ptr<SkeletonSolverFunctiond>

Definition at line 781 of file fwd.h.

◆ SkeletonSolverFunctiond_u

using momentum::SkeletonSolverFunctiond_u = typedef ::std::unique_ptr<SkeletonSolverFunctiond>

Definition at line 782 of file fwd.h.

◆ SkeletonSolverFunctiond_w

using momentum::SkeletonSolverFunctiond_w = typedef ::std::weak_ptr<SkeletonSolverFunctiond>

Definition at line 783 of file fwd.h.

◆ SkeletonState

using momentum::SkeletonState = typedef SkeletonStateT<float>

Definition at line 207 of file fwd.h.

◆ SkeletonState_const_p

using momentum::SkeletonState_const_p = typedef ::std::shared_ptr<const SkeletonState>

Definition at line 213 of file fwd.h.

◆ SkeletonState_const_u

using momentum::SkeletonState_const_u = typedef ::std::unique_ptr<const SkeletonState>

Definition at line 214 of file fwd.h.

◆ SkeletonState_const_w

using momentum::SkeletonState_const_w = typedef ::std::weak_ptr<const SkeletonState>

Definition at line 215 of file fwd.h.

◆ SkeletonState_p

using momentum::SkeletonState_p = typedef ::std::shared_ptr<SkeletonState>

Definition at line 210 of file fwd.h.

◆ SkeletonState_u

using momentum::SkeletonState_u = typedef ::std::unique_ptr<SkeletonState>

Definition at line 211 of file fwd.h.

◆ SkeletonState_w

using momentum::SkeletonState_w = typedef ::std::weak_ptr<SkeletonState>

Definition at line 212 of file fwd.h.

◆ SkeletonStated

using momentum::SkeletonStated = typedef SkeletonStateT<double>

Definition at line 208 of file fwd.h.

◆ SkeletonStated_const_p

using momentum::SkeletonStated_const_p = typedef ::std::shared_ptr<const SkeletonStated>

Definition at line 220 of file fwd.h.

◆ SkeletonStated_const_u

using momentum::SkeletonStated_const_u = typedef ::std::unique_ptr<const SkeletonStated>

Definition at line 221 of file fwd.h.

◆ SkeletonStated_const_w

using momentum::SkeletonStated_const_w = typedef ::std::weak_ptr<const SkeletonStated>

Definition at line 222 of file fwd.h.

◆ SkeletonStated_p

using momentum::SkeletonStated_p = typedef ::std::shared_ptr<SkeletonStated>

Definition at line 217 of file fwd.h.

◆ SkeletonStated_u

using momentum::SkeletonStated_u = typedef ::std::unique_ptr<SkeletonStated>

Definition at line 218 of file fwd.h.

◆ SkeletonStated_w

using momentum::SkeletonStated_w = typedef ::std::weak_ptr<SkeletonStated>

Definition at line 219 of file fwd.h.

◆ SkinnedLocator_const_p

using momentum::SkinnedLocator_const_p = typedef ::std::shared_ptr<const SkinnedLocator>

Definition at line 68 of file fwd.h.

◆ SkinnedLocator_const_u

using momentum::SkinnedLocator_const_u = typedef ::std::unique_ptr<const SkinnedLocator>

Definition at line 69 of file fwd.h.

◆ SkinnedLocator_const_w

using momentum::SkinnedLocator_const_w = typedef ::std::weak_ptr<const SkinnedLocator>

Definition at line 70 of file fwd.h.

◆ SkinnedLocator_p

using momentum::SkinnedLocator_p = typedef ::std::shared_ptr<SkinnedLocator>

Definition at line 65 of file fwd.h.

◆ SkinnedLocator_u

using momentum::SkinnedLocator_u = typedef ::std::unique_ptr<SkinnedLocator>

Definition at line 66 of file fwd.h.

◆ SkinnedLocator_w

using momentum::SkinnedLocator_w = typedef ::std::weak_ptr<SkinnedLocator>

Definition at line 67 of file fwd.h.

◆ SkinnedLocatorConstraint

using momentum::SkinnedLocatorConstraint = typedef SkinnedLocatorConstraintT<float>

Definition at line 203 of file fwd.h.

◆ SkinnedLocatorConstraint_const_p

using momentum::SkinnedLocatorConstraint_const_p = typedef ::std::shared_ptr<const SkinnedLocatorConstraint>

Definition at line 209 of file fwd.h.

◆ SkinnedLocatorConstraint_const_u

using momentum::SkinnedLocatorConstraint_const_u = typedef ::std::unique_ptr<const SkinnedLocatorConstraint>

Definition at line 210 of file fwd.h.

◆ SkinnedLocatorConstraint_const_w

using momentum::SkinnedLocatorConstraint_const_w = typedef ::std::weak_ptr<const SkinnedLocatorConstraint>

Definition at line 211 of file fwd.h.

◆ SkinnedLocatorConstraint_p

using momentum::SkinnedLocatorConstraint_p = typedef ::std::shared_ptr<SkinnedLocatorConstraint>

Definition at line 206 of file fwd.h.

◆ SkinnedLocatorConstraint_u

using momentum::SkinnedLocatorConstraint_u = typedef ::std::unique_ptr<SkinnedLocatorConstraint>

Definition at line 207 of file fwd.h.

◆ SkinnedLocatorConstraint_w

using momentum::SkinnedLocatorConstraint_w = typedef ::std::weak_ptr<SkinnedLocatorConstraint>

Definition at line 208 of file fwd.h.

◆ SkinnedLocatorConstraintd

using momentum::SkinnedLocatorConstraintd = typedef SkinnedLocatorConstraintT<double>

Definition at line 204 of file fwd.h.

◆ SkinnedLocatorConstraintd_const_p

using momentum::SkinnedLocatorConstraintd_const_p = typedef ::std::shared_ptr<const SkinnedLocatorConstraintd>

Definition at line 216 of file fwd.h.

◆ SkinnedLocatorConstraintd_const_u

using momentum::SkinnedLocatorConstraintd_const_u = typedef ::std::unique_ptr<const SkinnedLocatorConstraintd>

Definition at line 217 of file fwd.h.

◆ SkinnedLocatorConstraintd_const_w

using momentum::SkinnedLocatorConstraintd_const_w = typedef ::std::weak_ptr<const SkinnedLocatorConstraintd>

Definition at line 218 of file fwd.h.

◆ SkinnedLocatorConstraintd_p

using momentum::SkinnedLocatorConstraintd_p = typedef ::std::shared_ptr<SkinnedLocatorConstraintd>

Definition at line 213 of file fwd.h.

◆ SkinnedLocatorConstraintd_u

using momentum::SkinnedLocatorConstraintd_u = typedef ::std::unique_ptr<SkinnedLocatorConstraintd>

Definition at line 214 of file fwd.h.

◆ SkinnedLocatorConstraintd_w

using momentum::SkinnedLocatorConstraintd_w = typedef ::std::weak_ptr<SkinnedLocatorConstraintd>

Definition at line 215 of file fwd.h.

◆ SkinnedLocatorErrorFunction

using momentum::SkinnedLocatorErrorFunction = typedef SkinnedLocatorErrorFunctionT<float>

Definition at line 790 of file fwd.h.

◆ SkinnedLocatorErrorFunction_const_p

using momentum::SkinnedLocatorErrorFunction_const_p = typedef ::std::shared_ptr<const SkinnedLocatorErrorFunction>

Definition at line 796 of file fwd.h.

◆ SkinnedLocatorErrorFunction_const_u

using momentum::SkinnedLocatorErrorFunction_const_u = typedef ::std::unique_ptr<const SkinnedLocatorErrorFunction>

Definition at line 797 of file fwd.h.

◆ SkinnedLocatorErrorFunction_const_w

using momentum::SkinnedLocatorErrorFunction_const_w = typedef ::std::weak_ptr<const SkinnedLocatorErrorFunction>

Definition at line 798 of file fwd.h.

◆ SkinnedLocatorErrorFunction_p

using momentum::SkinnedLocatorErrorFunction_p = typedef ::std::shared_ptr<SkinnedLocatorErrorFunction>

Definition at line 793 of file fwd.h.

◆ SkinnedLocatorErrorFunction_u

using momentum::SkinnedLocatorErrorFunction_u = typedef ::std::unique_ptr<SkinnedLocatorErrorFunction>

Definition at line 794 of file fwd.h.

◆ SkinnedLocatorErrorFunction_w

using momentum::SkinnedLocatorErrorFunction_w = typedef ::std::weak_ptr<SkinnedLocatorErrorFunction>

Definition at line 795 of file fwd.h.

◆ SkinnedLocatorErrorFunctiond

using momentum::SkinnedLocatorErrorFunctiond = typedef SkinnedLocatorErrorFunctionT<double>

Definition at line 791 of file fwd.h.

◆ SkinnedLocatorErrorFunctiond_const_p

using momentum::SkinnedLocatorErrorFunctiond_const_p = typedef ::std::shared_ptr<const SkinnedLocatorErrorFunctiond>

Definition at line 803 of file fwd.h.

◆ SkinnedLocatorErrorFunctiond_const_u

using momentum::SkinnedLocatorErrorFunctiond_const_u = typedef ::std::unique_ptr<const SkinnedLocatorErrorFunctiond>

Definition at line 804 of file fwd.h.

◆ SkinnedLocatorErrorFunctiond_const_w

using momentum::SkinnedLocatorErrorFunctiond_const_w = typedef ::std::weak_ptr<const SkinnedLocatorErrorFunctiond>

Definition at line 805 of file fwd.h.

◆ SkinnedLocatorErrorFunctiond_p

using momentum::SkinnedLocatorErrorFunctiond_p = typedef ::std::shared_ptr<SkinnedLocatorErrorFunctiond>

Definition at line 800 of file fwd.h.

◆ SkinnedLocatorErrorFunctiond_u

using momentum::SkinnedLocatorErrorFunctiond_u = typedef ::std::unique_ptr<SkinnedLocatorErrorFunctiond>

Definition at line 801 of file fwd.h.

◆ SkinnedLocatorErrorFunctiond_w

using momentum::SkinnedLocatorErrorFunctiond_w = typedef ::std::weak_ptr<SkinnedLocatorErrorFunctiond>

Definition at line 802 of file fwd.h.

◆ SkinnedLocatorList

using momentum::SkinnedLocatorList = typedef std::vector<SkinnedLocator>

A collection of locators attached to a skeleton.

Definition at line 78 of file skinned_locator.h.

◆ SkinnedLocatorTriangleConstraint

using momentum::SkinnedLocatorTriangleConstraint = typedef SkinnedLocatorTriangleConstraintT<float>

Definition at line 222 of file fwd.h.

◆ SkinnedLocatorTriangleConstraint_const_p

using momentum::SkinnedLocatorTriangleConstraint_const_p = typedef ::std::shared_ptr<const SkinnedLocatorTriangleConstraint>

Definition at line 228 of file fwd.h.

◆ SkinnedLocatorTriangleConstraint_const_u

using momentum::SkinnedLocatorTriangleConstraint_const_u = typedef ::std::unique_ptr<const SkinnedLocatorTriangleConstraint>

Definition at line 230 of file fwd.h.

◆ SkinnedLocatorTriangleConstraint_const_w

using momentum::SkinnedLocatorTriangleConstraint_const_w = typedef ::std::weak_ptr<const SkinnedLocatorTriangleConstraint>

Definition at line 232 of file fwd.h.

◆ SkinnedLocatorTriangleConstraint_p

using momentum::SkinnedLocatorTriangleConstraint_p = typedef ::std::shared_ptr<SkinnedLocatorTriangleConstraint>

Definition at line 225 of file fwd.h.

◆ SkinnedLocatorTriangleConstraint_u

using momentum::SkinnedLocatorTriangleConstraint_u = typedef ::std::unique_ptr<SkinnedLocatorTriangleConstraint>

Definition at line 226 of file fwd.h.

◆ SkinnedLocatorTriangleConstraint_w

using momentum::SkinnedLocatorTriangleConstraint_w = typedef ::std::weak_ptr<SkinnedLocatorTriangleConstraint>

Definition at line 227 of file fwd.h.

◆ SkinnedLocatorTriangleConstraintd

using momentum::SkinnedLocatorTriangleConstraintd = typedef SkinnedLocatorTriangleConstraintT<double>

Definition at line 223 of file fwd.h.

◆ SkinnedLocatorTriangleConstraintd_const_p

using momentum::SkinnedLocatorTriangleConstraintd_const_p = typedef ::std::shared_ptr<const SkinnedLocatorTriangleConstraintd>

Definition at line 238 of file fwd.h.

◆ SkinnedLocatorTriangleConstraintd_const_u

using momentum::SkinnedLocatorTriangleConstraintd_const_u = typedef ::std::unique_ptr<const SkinnedLocatorTriangleConstraintd>

Definition at line 240 of file fwd.h.

◆ SkinnedLocatorTriangleConstraintd_const_w

using momentum::SkinnedLocatorTriangleConstraintd_const_w = typedef ::std::weak_ptr<const SkinnedLocatorTriangleConstraintd>

Definition at line 242 of file fwd.h.

◆ SkinnedLocatorTriangleConstraintd_p

using momentum::SkinnedLocatorTriangleConstraintd_p = typedef ::std::shared_ptr<SkinnedLocatorTriangleConstraintd>

Definition at line 235 of file fwd.h.

◆ SkinnedLocatorTriangleConstraintd_u

using momentum::SkinnedLocatorTriangleConstraintd_u = typedef ::std::unique_ptr<SkinnedLocatorTriangleConstraintd>

Definition at line 236 of file fwd.h.

◆ SkinnedLocatorTriangleConstraintd_w

using momentum::SkinnedLocatorTriangleConstraintd_w = typedef ::std::weak_ptr<SkinnedLocatorTriangleConstraintd>

Definition at line 237 of file fwd.h.

◆ SkinnedLocatorTriangleErrorFunction

using momentum::SkinnedLocatorTriangleErrorFunction = typedef SkinnedLocatorTriangleErrorFunctionT<float>

Definition at line 809 of file fwd.h.

◆ SkinnedLocatorTriangleErrorFunction_const_p

using momentum::SkinnedLocatorTriangleErrorFunction_const_p = typedef ::std::shared_ptr<const SkinnedLocatorTriangleErrorFunction>

Definition at line 817 of file fwd.h.

◆ SkinnedLocatorTriangleErrorFunction_const_u

using momentum::SkinnedLocatorTriangleErrorFunction_const_u = typedef ::std::unique_ptr<const SkinnedLocatorTriangleErrorFunction>

Definition at line 819 of file fwd.h.

◆ SkinnedLocatorTriangleErrorFunction_const_w

using momentum::SkinnedLocatorTriangleErrorFunction_const_w = typedef ::std::weak_ptr<const SkinnedLocatorTriangleErrorFunction>

Definition at line 821 of file fwd.h.

◆ SkinnedLocatorTriangleErrorFunction_p

using momentum::SkinnedLocatorTriangleErrorFunction_p = typedef ::std::shared_ptr<SkinnedLocatorTriangleErrorFunction>

Definition at line 812 of file fwd.h.

◆ SkinnedLocatorTriangleErrorFunction_u

using momentum::SkinnedLocatorTriangleErrorFunction_u = typedef ::std::unique_ptr<SkinnedLocatorTriangleErrorFunction>

Definition at line 814 of file fwd.h.

◆ SkinnedLocatorTriangleErrorFunction_w

using momentum::SkinnedLocatorTriangleErrorFunction_w = typedef ::std::weak_ptr<SkinnedLocatorTriangleErrorFunction>

Definition at line 816 of file fwd.h.

◆ SkinnedLocatorTriangleErrorFunctiond

using momentum::SkinnedLocatorTriangleErrorFunctiond = typedef SkinnedLocatorTriangleErrorFunctionT<double>

Definition at line 810 of file fwd.h.

◆ SkinnedLocatorTriangleErrorFunctiond_const_p

using momentum::SkinnedLocatorTriangleErrorFunctiond_const_p = typedef ::std::shared_ptr<const SkinnedLocatorTriangleErrorFunctiond>

Definition at line 830 of file fwd.h.

◆ SkinnedLocatorTriangleErrorFunctiond_const_u

using momentum::SkinnedLocatorTriangleErrorFunctiond_const_u = typedef ::std::unique_ptr<const SkinnedLocatorTriangleErrorFunctiond>

Definition at line 832 of file fwd.h.

◆ SkinnedLocatorTriangleErrorFunctiond_const_w

using momentum::SkinnedLocatorTriangleErrorFunctiond_const_w = typedef ::std::weak_ptr<const SkinnedLocatorTriangleErrorFunctiond>

Definition at line 834 of file fwd.h.

◆ SkinnedLocatorTriangleErrorFunctiond_p

using momentum::SkinnedLocatorTriangleErrorFunctiond_p = typedef ::std::shared_ptr<SkinnedLocatorTriangleErrorFunctiond>

Definition at line 824 of file fwd.h.

◆ SkinnedLocatorTriangleErrorFunctiond_u

using momentum::SkinnedLocatorTriangleErrorFunctiond_u = typedef ::std::unique_ptr<SkinnedLocatorTriangleErrorFunctiond>

Definition at line 826 of file fwd.h.

◆ SkinnedLocatorTriangleErrorFunctiond_w

using momentum::SkinnedLocatorTriangleErrorFunctiond_w = typedef ::std::weak_ptr<SkinnedLocatorTriangleErrorFunctiond>

Definition at line 828 of file fwd.h.

◆ SkinWeights_const_p

using momentum::SkinWeights_const_p = typedef ::std::shared_ptr<const SkinWeights>

Definition at line 59 of file fwd.h.

◆ SkinWeights_const_u

using momentum::SkinWeights_const_u = typedef ::std::unique_ptr<const SkinWeights>

Definition at line 60 of file fwd.h.

◆ SkinWeights_const_w

using momentum::SkinWeights_const_w = typedef ::std::weak_ptr<const SkinWeights>

Definition at line 61 of file fwd.h.

◆ SkinWeights_p

using momentum::SkinWeights_p = typedef ::std::shared_ptr<SkinWeights>

Definition at line 56 of file fwd.h.

◆ SkinWeights_u

using momentum::SkinWeights_u = typedef ::std::unique_ptr<SkinWeights>

Definition at line 57 of file fwd.h.

◆ SkinWeights_w

using momentum::SkinWeights_w = typedef ::std::weak_ptr<SkinWeights>

Definition at line 58 of file fwd.h.

◆ Solver

using momentum::Solver = typedef SolverT<float>

Definition at line 38 of file fwd.h.

◆ Solver_const_p

using momentum::Solver_const_p = typedef ::std::shared_ptr<const Solver>

Definition at line 44 of file fwd.h.

◆ Solver_const_u

using momentum::Solver_const_u = typedef ::std::unique_ptr<const Solver>

Definition at line 45 of file fwd.h.

◆ Solver_const_w

using momentum::Solver_const_w = typedef ::std::weak_ptr<const Solver>

Definition at line 46 of file fwd.h.

◆ Solver_p

using momentum::Solver_p = typedef ::std::shared_ptr<Solver>

Definition at line 41 of file fwd.h.

◆ Solver_u

using momentum::Solver_u = typedef ::std::unique_ptr<Solver>

Definition at line 42 of file fwd.h.

◆ Solver_w

using momentum::Solver_w = typedef ::std::weak_ptr<Solver>

Definition at line 43 of file fwd.h.

◆ Solverd

using momentum::Solverd = typedef SolverT<double>

Definition at line 39 of file fwd.h.

◆ Solverd_const_p

using momentum::Solverd_const_p = typedef ::std::shared_ptr<const Solverd>

Definition at line 51 of file fwd.h.

◆ Solverd_const_u

using momentum::Solverd_const_u = typedef ::std::unique_ptr<const Solverd>

Definition at line 52 of file fwd.h.

◆ Solverd_const_w

using momentum::Solverd_const_w = typedef ::std::weak_ptr<const Solverd>

Definition at line 53 of file fwd.h.

◆ Solverd_p

using momentum::Solverd_p = typedef ::std::shared_ptr<Solverd>

Definition at line 48 of file fwd.h.

◆ Solverd_u

using momentum::Solverd_u = typedef ::std::unique_ptr<Solverd>

Definition at line 49 of file fwd.h.

◆ Solverd_w

using momentum::Solverd_w = typedef ::std::weak_ptr<Solverd>

Definition at line 50 of file fwd.h.

◆ SolverFunction

using momentum::SolverFunction = typedef SolverFunctionT<float>

Definition at line 57 of file fwd.h.

◆ SolverFunction_const_p

using momentum::SolverFunction_const_p = typedef ::std::shared_ptr<const SolverFunction>

Definition at line 63 of file fwd.h.

◆ SolverFunction_const_u

using momentum::SolverFunction_const_u = typedef ::std::unique_ptr<const SolverFunction>

Definition at line 64 of file fwd.h.

◆ SolverFunction_const_w

using momentum::SolverFunction_const_w = typedef ::std::weak_ptr<const SolverFunction>

Definition at line 65 of file fwd.h.

◆ SolverFunction_p

using momentum::SolverFunction_p = typedef ::std::shared_ptr<SolverFunction>

Definition at line 60 of file fwd.h.

◆ SolverFunction_u

using momentum::SolverFunction_u = typedef ::std::unique_ptr<SolverFunction>

Definition at line 61 of file fwd.h.

◆ SolverFunction_w

using momentum::SolverFunction_w = typedef ::std::weak_ptr<SolverFunction>

Definition at line 62 of file fwd.h.

◆ SolverFunctiond

using momentum::SolverFunctiond = typedef SolverFunctionT<double>

Definition at line 58 of file fwd.h.

◆ SolverFunctiond_const_p

using momentum::SolverFunctiond_const_p = typedef ::std::shared_ptr<const SolverFunctiond>

Definition at line 70 of file fwd.h.

◆ SolverFunctiond_const_u

using momentum::SolverFunctiond_const_u = typedef ::std::unique_ptr<const SolverFunctiond>

Definition at line 71 of file fwd.h.

◆ SolverFunctiond_const_w

using momentum::SolverFunctiond_const_w = typedef ::std::weak_ptr<const SolverFunctiond>

Definition at line 72 of file fwd.h.

◆ SolverFunctiond_p

using momentum::SolverFunctiond_p = typedef ::std::shared_ptr<SolverFunctiond>

Definition at line 67 of file fwd.h.

◆ SolverFunctiond_u

using momentum::SolverFunctiond_u = typedef ::std::unique_ptr<SolverFunctiond>

Definition at line 68 of file fwd.h.

◆ SolverFunctiond_w

using momentum::SolverFunctiond_w = typedef ::std::weak_ptr<SolverFunctiond>

Definition at line 69 of file fwd.h.

◆ SolverOptions_const_p

using momentum::SolverOptions_const_p = typedef ::std::shared_ptr<const SolverOptions>

Definition at line 23 of file fwd.h.

◆ SolverOptions_const_u

using momentum::SolverOptions_const_u = typedef ::std::unique_ptr<const SolverOptions>

Definition at line 24 of file fwd.h.

◆ SolverOptions_const_w

using momentum::SolverOptions_const_w = typedef ::std::weak_ptr<const SolverOptions>

Definition at line 25 of file fwd.h.

◆ SolverOptions_p

using momentum::SolverOptions_p = typedef ::std::shared_ptr<SolverOptions>

Definition at line 20 of file fwd.h.

◆ SolverOptions_u

using momentum::SolverOptions_u = typedef ::std::unique_ptr<SolverOptions>

Definition at line 21 of file fwd.h.

◆ SolverOptions_w

using momentum::SolverOptions_w = typedef ::std::weak_ptr<SolverOptions>

Definition at line 22 of file fwd.h.

◆ SparseMatrix

template<typename T >

using momentum::SparseMatrix = typedef Eigen::SparseMatrix<T>

Definition at line 178 of file types.h.

◆ SparseMatrixb

using momentum::SparseMatrixb = typedef SparseMatrix<std::uint8_t>

Definition at line 181 of file types.h.

◆ SparseMatrixd

using momentum::SparseMatrixd = typedef SparseMatrix<double>

Definition at line 180 of file types.h.

◆ SparseMatrixf

using momentum::SparseMatrixf = typedef SparseMatrix<float>

Definition at line 179 of file types.h.

◆ SparseMatrixi

using momentum::SparseMatrixi = typedef SparseMatrix<std::int32_t>

Definition at line 184 of file types.h.

◆ SparseMatrixs

using momentum::SparseMatrixs = typedef SparseMatrix<std::uint16_t>

Definition at line 182 of file types.h.

◆ SparseMatrixu

using momentum::SparseMatrixu = typedef SparseMatrix<std::uint32_t>

Definition at line 183 of file types.h.

◆ SparseRowMatrix

template<typename T >

using momentum::SparseRowMatrix = typedef Eigen::SparseMatrix<T, Eigen::RowMajor>

Definition at line 187 of file types.h.

◆ SparseRowMatrixb

using momentum::SparseRowMatrixb = typedef SparseRowMatrix<std::uint8_t>

Definition at line 190 of file types.h.

◆ SparseRowMatrixd

using momentum::SparseRowMatrixd = typedef SparseRowMatrix<double>

Definition at line 189 of file types.h.

◆ SparseRowMatrixf

using momentum::SparseRowMatrixf = typedef SparseRowMatrix<float>

Definition at line 188 of file types.h.

◆ SparseRowMatrixi

using momentum::SparseRowMatrixi = typedef SparseRowMatrix<std::int32_t>

Definition at line 193 of file types.h.

◆ SparseRowMatrixs

using momentum::SparseRowMatrixs = typedef SparseRowMatrix<std::uint16_t>

Definition at line 191 of file types.h.

◆ SparseRowMatrixu

using momentum::SparseRowMatrixu = typedef SparseRowMatrix<std::uint32_t>

Definition at line 192 of file types.h.

◆ StateErrorFunction

using momentum::StateErrorFunction = typedef StateErrorFunctionT<float>

Definition at line 839 of file fwd.h.

◆ StateErrorFunction_const_p

using momentum::StateErrorFunction_const_p = typedef ::std::shared_ptr<const StateErrorFunction>

Definition at line 845 of file fwd.h.

◆ StateErrorFunction_const_u

using momentum::StateErrorFunction_const_u = typedef ::std::unique_ptr<const StateErrorFunction>

Definition at line 846 of file fwd.h.

◆ StateErrorFunction_const_w

using momentum::StateErrorFunction_const_w = typedef ::std::weak_ptr<const StateErrorFunction>

Definition at line 847 of file fwd.h.

◆ StateErrorFunction_p

using momentum::StateErrorFunction_p = typedef ::std::shared_ptr<StateErrorFunction>

Definition at line 842 of file fwd.h.

◆ StateErrorFunction_u

using momentum::StateErrorFunction_u = typedef ::std::unique_ptr<StateErrorFunction>

Definition at line 843 of file fwd.h.

◆ StateErrorFunction_w

using momentum::StateErrorFunction_w = typedef ::std::weak_ptr<StateErrorFunction>

Definition at line 844 of file fwd.h.

◆ StateErrorFunctiond

using momentum::StateErrorFunctiond = typedef StateErrorFunctionT<double>

Definition at line 840 of file fwd.h.

◆ StateErrorFunctiond_const_p

using momentum::StateErrorFunctiond_const_p = typedef ::std::shared_ptr<const StateErrorFunctiond>

Definition at line 852 of file fwd.h.

◆ StateErrorFunctiond_const_u

using momentum::StateErrorFunctiond_const_u = typedef ::std::unique_ptr<const StateErrorFunctiond>

Definition at line 853 of file fwd.h.

◆ StateErrorFunctiond_const_w

using momentum::StateErrorFunctiond_const_w = typedef ::std::weak_ptr<const StateErrorFunctiond>

Definition at line 854 of file fwd.h.

◆ StateErrorFunctiond_p

using momentum::StateErrorFunctiond_p = typedef ::std::shared_ptr<StateErrorFunctiond>

Definition at line 849 of file fwd.h.

◆ StateErrorFunctiond_u

using momentum::StateErrorFunctiond_u = typedef ::std::unique_ptr<StateErrorFunctiond>

Definition at line 850 of file fwd.h.

◆ StateErrorFunctiond_w

using momentum::StateErrorFunctiond_w = typedef ::std::weak_ptr<StateErrorFunctiond>

Definition at line 851 of file fwd.h.

◆ StateSequenceErrorFunction

using momentum::StateSequenceErrorFunction = typedef StateSequenceErrorFunctionT<float>

Definition at line 164 of file fwd.h.

◆ StateSequenceErrorFunction_const_p

using momentum::StateSequenceErrorFunction_const_p = typedef ::std::shared_ptr<const StateSequenceErrorFunction>

Definition at line 170 of file fwd.h.

◆ StateSequenceErrorFunction_const_u

using momentum::StateSequenceErrorFunction_const_u = typedef ::std::unique_ptr<const StateSequenceErrorFunction>

Definition at line 171 of file fwd.h.

◆ StateSequenceErrorFunction_const_w

using momentum::StateSequenceErrorFunction_const_w = typedef ::std::weak_ptr<const StateSequenceErrorFunction>

Definition at line 172 of file fwd.h.

◆ StateSequenceErrorFunction_p

using momentum::StateSequenceErrorFunction_p = typedef ::std::shared_ptr<StateSequenceErrorFunction>

Definition at line 167 of file fwd.h.

◆ StateSequenceErrorFunction_u

using momentum::StateSequenceErrorFunction_u = typedef ::std::unique_ptr<StateSequenceErrorFunction>

Definition at line 168 of file fwd.h.

◆ StateSequenceErrorFunction_w

using momentum::StateSequenceErrorFunction_w = typedef ::std::weak_ptr<StateSequenceErrorFunction>

Definition at line 169 of file fwd.h.

◆ StateSequenceErrorFunctiond

using momentum::StateSequenceErrorFunctiond = typedef StateSequenceErrorFunctionT<double>

Definition at line 165 of file fwd.h.

◆ StateSequenceErrorFunctiond_const_p

using momentum::StateSequenceErrorFunctiond_const_p = typedef ::std::shared_ptr<const StateSequenceErrorFunctiond>

Definition at line 177 of file fwd.h.

◆ StateSequenceErrorFunctiond_const_u

using momentum::StateSequenceErrorFunctiond_const_u = typedef ::std::unique_ptr<const StateSequenceErrorFunctiond>

Definition at line 178 of file fwd.h.

◆ StateSequenceErrorFunctiond_const_w

using momentum::StateSequenceErrorFunctiond_const_w = typedef ::std::weak_ptr<const StateSequenceErrorFunctiond>

Definition at line 179 of file fwd.h.

◆ StateSequenceErrorFunctiond_p

using momentum::StateSequenceErrorFunctiond_p = typedef ::std::shared_ptr<StateSequenceErrorFunctiond>

Definition at line 174 of file fwd.h.

◆ StateSequenceErrorFunctiond_u

using momentum::StateSequenceErrorFunctiond_u = typedef ::std::unique_ptr<StateSequenceErrorFunctiond>

Definition at line 175 of file fwd.h.

◆ StateSequenceErrorFunctiond_w

using momentum::StateSequenceErrorFunctiond_w = typedef ::std::weak_ptr<StateSequenceErrorFunctiond>

Definition at line 176 of file fwd.h.

◆ SubsetGaussNewtonSolver

using momentum::SubsetGaussNewtonSolver = typedef SubsetGaussNewtonSolverT<float>

Definition at line 114 of file fwd.h.

◆ SubsetGaussNewtonSolver_const_p

using momentum::SubsetGaussNewtonSolver_const_p = typedef ::std::shared_ptr<const SubsetGaussNewtonSolver>

Definition at line 120 of file fwd.h.

◆ SubsetGaussNewtonSolver_const_u

using momentum::SubsetGaussNewtonSolver_const_u = typedef ::std::unique_ptr<const SubsetGaussNewtonSolver>

Definition at line 121 of file fwd.h.

◆ SubsetGaussNewtonSolver_const_w

using momentum::SubsetGaussNewtonSolver_const_w = typedef ::std::weak_ptr<const SubsetGaussNewtonSolver>

Definition at line 122 of file fwd.h.

◆ SubsetGaussNewtonSolver_p

using momentum::SubsetGaussNewtonSolver_p = typedef ::std::shared_ptr<SubsetGaussNewtonSolver>

Definition at line 117 of file fwd.h.

◆ SubsetGaussNewtonSolver_u

using momentum::SubsetGaussNewtonSolver_u = typedef ::std::unique_ptr<SubsetGaussNewtonSolver>

Definition at line 118 of file fwd.h.

◆ SubsetGaussNewtonSolver_w

using momentum::SubsetGaussNewtonSolver_w = typedef ::std::weak_ptr<SubsetGaussNewtonSolver>

Definition at line 119 of file fwd.h.

◆ SubsetGaussNewtonSolverd

using momentum::SubsetGaussNewtonSolverd = typedef SubsetGaussNewtonSolverT<double>

Definition at line 115 of file fwd.h.

◆ SubsetGaussNewtonSolverd_const_p

using momentum::SubsetGaussNewtonSolverd_const_p = typedef ::std::shared_ptr<const SubsetGaussNewtonSolverd>

Definition at line 127 of file fwd.h.

◆ SubsetGaussNewtonSolverd_const_u

using momentum::SubsetGaussNewtonSolverd_const_u = typedef ::std::unique_ptr<const SubsetGaussNewtonSolverd>

Definition at line 128 of file fwd.h.

◆ SubsetGaussNewtonSolverd_const_w

using momentum::SubsetGaussNewtonSolverd_const_w = typedef ::std::weak_ptr<const SubsetGaussNewtonSolverd>

Definition at line 129 of file fwd.h.

◆ SubsetGaussNewtonSolverd_p

using momentum::SubsetGaussNewtonSolverd_p = typedef ::std::shared_ptr<SubsetGaussNewtonSolverd>

Definition at line 124 of file fwd.h.

◆ SubsetGaussNewtonSolverd_u

using momentum::SubsetGaussNewtonSolverd_u = typedef ::std::unique_ptr<SubsetGaussNewtonSolverd>

Definition at line 125 of file fwd.h.

◆ SubsetGaussNewtonSolverd_w

using momentum::SubsetGaussNewtonSolverd_w = typedef ::std::weak_ptr<SubsetGaussNewtonSolverd>

Definition at line 126 of file fwd.h.

◆ TaperedCapsule

using momentum::TaperedCapsule = typedef TaperedCapsuleT<float>

Definition at line 245 of file fwd.h.

◆ TaperedCapsule_const_p

using momentum::TaperedCapsule_const_p = typedef ::std::shared_ptr<const TaperedCapsule>

Definition at line 251 of file fwd.h.

◆ TaperedCapsule_const_u

using momentum::TaperedCapsule_const_u = typedef ::std::unique_ptr<const TaperedCapsule>

Definition at line 252 of file fwd.h.

◆ TaperedCapsule_const_w

using momentum::TaperedCapsule_const_w = typedef ::std::weak_ptr<const TaperedCapsule>

Definition at line 253 of file fwd.h.

◆ TaperedCapsule_p

using momentum::TaperedCapsule_p = typedef ::std::shared_ptr<TaperedCapsule>

Definition at line 248 of file fwd.h.

◆ TaperedCapsule_u

using momentum::TaperedCapsule_u = typedef ::std::unique_ptr<TaperedCapsule>

Definition at line 249 of file fwd.h.

◆ TaperedCapsule_w

using momentum::TaperedCapsule_w = typedef ::std::weak_ptr<TaperedCapsule>

Definition at line 250 of file fwd.h.

◆ TaperedCapsuled

using momentum::TaperedCapsuled = typedef TaperedCapsuleT<double>

Definition at line 246 of file fwd.h.

◆ TaperedCapsuled_const_p

using momentum::TaperedCapsuled_const_p = typedef ::std::shared_ptr<const TaperedCapsuled>

Definition at line 258 of file fwd.h.

◆ TaperedCapsuled_const_u

using momentum::TaperedCapsuled_const_u = typedef ::std::unique_ptr<const TaperedCapsuled>

Definition at line 259 of file fwd.h.

◆ TaperedCapsuled_const_w

using momentum::TaperedCapsuled_const_w = typedef ::std::weak_ptr<const TaperedCapsuled>

Definition at line 260 of file fwd.h.

◆ TaperedCapsuled_p

using momentum::TaperedCapsuled_p = typedef ::std::shared_ptr<TaperedCapsuled>

Definition at line 255 of file fwd.h.

◆ TaperedCapsuled_u

using momentum::TaperedCapsuled_u = typedef ::std::unique_ptr<TaperedCapsuled>

Definition at line 256 of file fwd.h.

◆ TaperedCapsuled_w

using momentum::TaperedCapsuled_w = typedef ::std::weak_ptr<TaperedCapsuled>

Definition at line 257 of file fwd.h.

◆ Transform

typedef TransformT< float > momentum::Transform

Definition at line 58 of file fwd.h.

◆ Transform_const_p

using momentum::Transform_const_p = typedef ::std::shared_ptr<const Transform>

Definition at line 64 of file fwd.h.

◆ Transform_const_u

using momentum::Transform_const_u = typedef ::std::unique_ptr<const Transform>

Definition at line 65 of file fwd.h.

◆ Transform_const_w

using momentum::Transform_const_w = typedef ::std::weak_ptr<const Transform>

Definition at line 66 of file fwd.h.

◆ Transform_p

using momentum::Transform_p = typedef ::std::shared_ptr<Transform>

Definition at line 61 of file fwd.h.

◆ Transform_u

using momentum::Transform_u = typedef ::std::unique_ptr<Transform>

Definition at line 62 of file fwd.h.

◆ Transform_w

using momentum::Transform_w = typedef ::std::weak_ptr<Transform>

Definition at line 63 of file fwd.h.

◆ TransformationList

using momentum::TransformationList = typedef std::vector<Affine3f>

Definition at line 391 of file types.h.

◆ TransformationListT

template<typename T >

using momentum::TransformationListT = typedef std::vector<Affine3<T> >

Definition at line 393 of file types.h.

◆ Transformd

using momentum::Transformd = typedef TransformT<double>

Definition at line 59 of file fwd.h.

◆ Transformd_const_p

using momentum::Transformd_const_p = typedef ::std::shared_ptr<const Transformd>

Definition at line 71 of file fwd.h.

◆ Transformd_const_u

using momentum::Transformd_const_u = typedef ::std::unique_ptr<const Transformd>

Definition at line 72 of file fwd.h.

◆ Transformd_const_w

using momentum::Transformd_const_w = typedef ::std::weak_ptr<const Transformd>

Definition at line 73 of file fwd.h.

◆ Transformd_p

using momentum::Transformd_p = typedef ::std::shared_ptr<Transformd>

Definition at line 68 of file fwd.h.

◆ Transformd_u

using momentum::Transformd_u = typedef ::std::unique_ptr<Transformd>

Definition at line 69 of file fwd.h.

◆ Transformd_w

using momentum::Transformd_w = typedef ::std::weak_ptr<Transformd>

Definition at line 70 of file fwd.h.

◆ TransformList

using momentum::TransformList = typedef TransformListT<float>

Definition at line 227 of file transform.h.

◆ TransformListT

template<typename T >

using momentum::TransformListT = typedef std::vector<TransformT<T> >

Definition at line 214 of file transform.h.

◆ Translation3

template<typename T >

using momentum::Translation3 = typedef Eigen::Translation<T, 3>

Definition at line 376 of file types.h.

◆ Translation3d

using momentum::Translation3d = typedef Translation3<double>

Definition at line 378 of file types.h.

◆ Translation3f

using momentum::Translation3f = typedef Translation3<float>

Definition at line 377 of file types.h.

◆ TriangleArray

using momentum::TriangleArray = typedef Matrix3Xi

Definition at line 397 of file types.h.

◆ TrustRegionQR

using momentum::TrustRegionQR = typedef TrustRegionQRT<float>

Definition at line 858 of file fwd.h.

◆ TrustRegionQR_const_p

using momentum::TrustRegionQR_const_p = typedef ::std::shared_ptr<const TrustRegionQR>

Definition at line 864 of file fwd.h.

◆ TrustRegionQR_const_u

using momentum::TrustRegionQR_const_u = typedef ::std::unique_ptr<const TrustRegionQR>

Definition at line 865 of file fwd.h.

◆ TrustRegionQR_const_w

using momentum::TrustRegionQR_const_w = typedef ::std::weak_ptr<const TrustRegionQR>

Definition at line 866 of file fwd.h.

◆ TrustRegionQR_p

using momentum::TrustRegionQR_p = typedef ::std::shared_ptr<TrustRegionQR>

Definition at line 861 of file fwd.h.

◆ TrustRegionQR_u

using momentum::TrustRegionQR_u = typedef ::std::unique_ptr<TrustRegionQR>

Definition at line 862 of file fwd.h.

◆ TrustRegionQR_w

using momentum::TrustRegionQR_w = typedef ::std::weak_ptr<TrustRegionQR>

Definition at line 863 of file fwd.h.

◆ TrustRegionQRd

using momentum::TrustRegionQRd = typedef TrustRegionQRT<double>

Definition at line 859 of file fwd.h.

◆ TrustRegionQRd_const_p

using momentum::TrustRegionQRd_const_p = typedef ::std::shared_ptr<const TrustRegionQRd>

Definition at line 871 of file fwd.h.

◆ TrustRegionQRd_const_u

using momentum::TrustRegionQRd_const_u = typedef ::std::unique_ptr<const TrustRegionQRd>

Definition at line 872 of file fwd.h.

◆ TrustRegionQRd_const_w

using momentum::TrustRegionQRd_const_w = typedef ::std::weak_ptr<const TrustRegionQRd>

Definition at line 873 of file fwd.h.

◆ TrustRegionQRd_p

using momentum::TrustRegionQRd_p = typedef ::std::shared_ptr<TrustRegionQRd>

Definition at line 868 of file fwd.h.

◆ TrustRegionQRd_u

using momentum::TrustRegionQRd_u = typedef ::std::unique_ptr<TrustRegionQRd>

Definition at line 869 of file fwd.h.

◆ TrustRegionQRd_w

using momentum::TrustRegionQRd_w = typedef ::std::weak_ptr<TrustRegionQRd>

Definition at line 870 of file fwd.h.

◆ UnionErrorFunction

using momentum::UnionErrorFunction = typedef UnionErrorFunctionT<float>

Definition at line 368 of file fwd.h.

◆ UnionErrorFunction_const_p

using momentum::UnionErrorFunction_const_p = typedef ::std::shared_ptr<const UnionErrorFunction>

Definition at line 374 of file fwd.h.

◆ UnionErrorFunction_const_u

using momentum::UnionErrorFunction_const_u = typedef ::std::unique_ptr<const UnionErrorFunction>

Definition at line 375 of file fwd.h.

◆ UnionErrorFunction_const_w

using momentum::UnionErrorFunction_const_w = typedef ::std::weak_ptr<const UnionErrorFunction>

Definition at line 376 of file fwd.h.

◆ UnionErrorFunction_p

using momentum::UnionErrorFunction_p = typedef ::std::shared_ptr<UnionErrorFunction>

Definition at line 371 of file fwd.h.

◆ UnionErrorFunction_u

using momentum::UnionErrorFunction_u = typedef ::std::unique_ptr<UnionErrorFunction>

Definition at line 372 of file fwd.h.

◆ UnionErrorFunction_w

using momentum::UnionErrorFunction_w = typedef ::std::weak_ptr<UnionErrorFunction>

Definition at line 373 of file fwd.h.

◆ UnionErrorFunctiond

using momentum::UnionErrorFunctiond = typedef UnionErrorFunctionT<double>

Definition at line 369 of file fwd.h.

◆ UnionErrorFunctiond_const_p

using momentum::UnionErrorFunctiond_const_p = typedef ::std::shared_ptr<const UnionErrorFunctiond>

Definition at line 381 of file fwd.h.

◆ UnionErrorFunctiond_const_u

using momentum::UnionErrorFunctiond_const_u = typedef ::std::unique_ptr<const UnionErrorFunctiond>

Definition at line 382 of file fwd.h.

◆ UnionErrorFunctiond_const_w

using momentum::UnionErrorFunctiond_const_w = typedef ::std::weak_ptr<const UnionErrorFunctiond>

Definition at line 383 of file fwd.h.

◆ UnionErrorFunctiond_p

using momentum::UnionErrorFunctiond_p = typedef ::std::shared_ptr<UnionErrorFunctiond>

Definition at line 378 of file fwd.h.

◆ UnionErrorFunctiond_u

using momentum::UnionErrorFunctiond_u = typedef ::std::unique_ptr<UnionErrorFunctiond>

Definition at line 379 of file fwd.h.

◆ UnionErrorFunctiond_w

using momentum::UnionErrorFunctiond_w = typedef ::std::weak_ptr<UnionErrorFunctiond>

Definition at line 380 of file fwd.h.

◆ Vector

template<typename T , int Dim, int Options = 0>

using momentum::Vector = typedef Eigen::Matrix<T, Dim, 1, Options>

Definition at line 196 of file types.h.

◆ Vector0

template<typename T >

using momentum::Vector0 = typedef Vector<T, 0>

Definition at line 222 of file types.h.

◆ Vector0b

using momentum::Vector0b = typedef Vector0<std::uint8_t>

Definition at line 258 of file types.h.

◆ Vector0d

using momentum::Vector0d = typedef Vector0<double>

Definition at line 250 of file types.h.

◆ Vector0f

using momentum::Vector0f = typedef Vector0<float>

Definition at line 240 of file types.h.

◆ Vector0i

using momentum::Vector0i = typedef Vector0<std::int32_t>

Definition at line 282 of file types.h.

◆ Vector0s

using momentum::Vector0s = typedef Vector0<std::uint16_t>

Definition at line 266 of file types.h.

◆ Vector0u

using momentum::Vector0u = typedef Vector0<std::uint32_t>

Definition at line 274 of file types.h.

◆ Vector1

template<typename T >

using momentum::Vector1 = typedef Vector<T, 1>

Definition at line 224 of file types.h.

◆ Vector1b

using momentum::Vector1b = typedef Vector1<std::uint8_t>

Definition at line 259 of file types.h.

◆ Vector1d

using momentum::Vector1d = typedef Vector1<double>

Definition at line 251 of file types.h.

◆ Vector1f

using momentum::Vector1f = typedef Vector1<float>

Definition at line 241 of file types.h.

◆ Vector1i

using momentum::Vector1i = typedef Vector1<std::int32_t>

Definition at line 283 of file types.h.

◆ Vector1s

using momentum::Vector1s = typedef Vector1<std::uint16_t>

Definition at line 267 of file types.h.

◆ Vector1u

using momentum::Vector1u = typedef Vector1<std::uint32_t>

Definition at line 275 of file types.h.

◆ Vector2

template<typename T >

using momentum::Vector2 = typedef Vector<T, 2>

Definition at line 226 of file types.h.

◆ Vector2b

using momentum::Vector2b = typedef Vector2<std::uint8_t>

Definition at line 260 of file types.h.

◆ Vector2d

using momentum::Vector2d = typedef Vector2<double>

Definition at line 252 of file types.h.

◆ Vector2dP

using momentum::Vector2dP = typedef Vector2P<double>

Definition at line 56 of file simd.h.

◆ Vector2f

using momentum::Vector2f = typedef Vector2<float>

Definition at line 242 of file types.h.

◆ Vector2fP

using momentum::Vector2fP = typedef Vector2P<float>

Definition at line 53 of file simd.h.

◆ Vector2i

using momentum::Vector2i = typedef Vector2<std::int32_t>

Definition at line 284 of file types.h.

◆ Vector2P

template<typename T >

using momentum::Vector2P = typedef VectorP<T, 2>

Definition at line 48 of file simd.h.

◆ Vector2s

using momentum::Vector2s = typedef Vector2<std::uint16_t>

Definition at line 268 of file types.h.

◆ Vector2u

using momentum::Vector2u = typedef Vector2<std::uint32_t>

Definition at line 276 of file types.h.

◆ Vector3

template<typename T >

using momentum::Vector3 = typedef Vector<T, 3>

Definition at line 228 of file types.h.

◆ Vector3b

using momentum::Vector3b = typedef Vector3<std::uint8_t>

Definition at line 261 of file types.h.

◆ Vector3d

using momentum::Vector3d = typedef Vector3<double>

Definition at line 253 of file types.h.

◆ Vector3dP

using momentum::Vector3dP = typedef Vector3P<double>

Definition at line 57 of file simd.h.

◆ Vector3f

using momentum::Vector3f = typedef Vector3<float>

Definition at line 243 of file types.h.

◆ Vector3fP

using momentum::Vector3fP = typedef Vector3P<float>

Definition at line 54 of file simd.h.

◆ Vector3i

using momentum::Vector3i = typedef Vector3<std::int32_t>

Definition at line 285 of file types.h.

◆ Vector3P

template<typename T >

using momentum::Vector3P = typedef VectorP<T, 3>

Definition at line 51 of file simd.h.

◆ Vector3s

using momentum::Vector3s = typedef Vector3<std::uint16_t>

Definition at line 269 of file types.h.

◆ Vector3u

using momentum::Vector3u = typedef Vector3<std::uint32_t>

Definition at line 277 of file types.h.

◆ Vector4

template<typename T >

using momentum::Vector4 = typedef Vector<T, 4>

Definition at line 230 of file types.h.

◆ Vector4b

using momentum::Vector4b = typedef Vector4<std::uint8_t>

Definition at line 262 of file types.h.

◆ Vector4d

using momentum::Vector4d = typedef Vector4<double>

Definition at line 254 of file types.h.

◆ Vector4f

using momentum::Vector4f = typedef Vector4<float>

Definition at line 244 of file types.h.

◆ Vector4i

using momentum::Vector4i = typedef Vector4<std::int32_t>

Definition at line 286 of file types.h.

◆ Vector4s

using momentum::Vector4s = typedef Vector4<std::uint16_t>

Definition at line 270 of file types.h.

◆ Vector4u

using momentum::Vector4u = typedef Vector4<std::uint32_t>

Definition at line 278 of file types.h.

◆ Vector5

template<typename T >

using momentum::Vector5 = typedef Vector<T, 5>

Definition at line 232 of file types.h.

◆ Vector5b

using momentum::Vector5b = typedef Vector5<std::uint8_t>

Definition at line 263 of file types.h.

◆ Vector5d

using momentum::Vector5d = typedef Vector5<double>

Definition at line 255 of file types.h.

◆ Vector5f

using momentum::Vector5f = typedef Vector5<float>

Definition at line 245 of file types.h.

◆ Vector5i

using momentum::Vector5i = typedef Vector5<std::int32_t>

Definition at line 287 of file types.h.

◆ Vector5s

using momentum::Vector5s = typedef Vector5<std::uint16_t>

Definition at line 271 of file types.h.

◆ Vector5u

using momentum::Vector5u = typedef Vector5<std::uint32_t>

Definition at line 279 of file types.h.

◆ Vector6

template<typename T >

using momentum::Vector6 = typedef Vector<T, 6>

Definition at line 234 of file types.h.

◆ Vector6b

using momentum::Vector6b = typedef Vector6<std::uint8_t>

Definition at line 264 of file types.h.

◆ Vector6d

using momentum::Vector6d = typedef Vector6<double>

Definition at line 256 of file types.h.

◆ Vector6f

using momentum::Vector6f = typedef Vector6<float>

Definition at line 246 of file types.h.

◆ Vector6i

using momentum::Vector6i = typedef Vector6<std::int32_t>

Definition at line 288 of file types.h.

◆ Vector6s

using momentum::Vector6s = typedef Vector6<std::uint16_t>

Definition at line 272 of file types.h.

◆ Vector6u

using momentum::Vector6u = typedef Vector6<std::uint32_t>

Definition at line 280 of file types.h.

◆ Vector7

template<typename T >

using momentum::Vector7 = typedef Vector<T, 7>

Definition at line 236 of file types.h.

◆ Vector7f

using momentum::Vector7f = typedef Vector7<float>

Definition at line 247 of file types.h.

◆ Vector8

template<typename T >

using momentum::Vector8 = typedef Vector<T, 8>

Definition at line 238 of file types.h.

template<typename T >

using momentum::VectorX = typedef Vector<T, Dynamic>

Definition at line 199 of file types.h.

◆ VectorXb

using momentum::VectorXb = typedef VectorX<std::uint8_t>

Definition at line 203 of file types.h.

◆ VectorXd

using momentum::VectorXd = typedef VectorX<double>

Definition at line 202 of file types.h.

◆ VectorXf

using momentum::VectorXf = typedef VectorX<float>

Definition at line 201 of file types.h.

◆ VectorXi

using momentum::VectorXi = typedef VectorX<std::int32_t>

Definition at line 206 of file types.h.

◆ VectorXs

using momentum::VectorXs = typedef VectorX<std::uint16_t>

Definition at line 204 of file types.h.

◆ VectorXu

using momentum::VectorXu = typedef VectorX<std::uint32_t>

Definition at line 205 of file types.h.

◆ VertexArray

using momentum::VertexArray = typedef Matrix3Xf

Definition at line 395 of file types.h.

◆ VertexConstraint

using momentum::VertexConstraint = typedef VertexConstraintT<float>

Definition at line 247 of file fwd.h.

◆ VertexConstraint_const_p

using momentum::VertexConstraint_const_p = typedef ::std::shared_ptr<const VertexConstraint>

Definition at line 253 of file fwd.h.

◆ VertexConstraint_const_u

using momentum::VertexConstraint_const_u = typedef ::std::unique_ptr<const VertexConstraint>

Definition at line 254 of file fwd.h.

◆ VertexConstraint_const_w

using momentum::VertexConstraint_const_w = typedef ::std::weak_ptr<const VertexConstraint>

Definition at line 255 of file fwd.h.

◆ VertexConstraint_p

using momentum::VertexConstraint_p = typedef ::std::shared_ptr<VertexConstraint>

Definition at line 250 of file fwd.h.

◆ VertexConstraint_u

using momentum::VertexConstraint_u = typedef ::std::unique_ptr<VertexConstraint>

Definition at line 251 of file fwd.h.

◆ VertexConstraint_w

using momentum::VertexConstraint_w = typedef ::std::weak_ptr<VertexConstraint>

Definition at line 252 of file fwd.h.

◆ VertexConstraintd

using momentum::VertexConstraintd = typedef VertexConstraintT<double>

Definition at line 248 of file fwd.h.

◆ VertexConstraintd_const_p

using momentum::VertexConstraintd_const_p = typedef ::std::shared_ptr<const VertexConstraintd>

Definition at line 260 of file fwd.h.

◆ VertexConstraintd_const_u

using momentum::VertexConstraintd_const_u = typedef ::std::unique_ptr<const VertexConstraintd>

Definition at line 261 of file fwd.h.

◆ VertexConstraintd_const_w

using momentum::VertexConstraintd_const_w = typedef ::std::weak_ptr<const VertexConstraintd>

Definition at line 262 of file fwd.h.

◆ VertexConstraintd_p

using momentum::VertexConstraintd_p = typedef ::std::shared_ptr<VertexConstraintd>

Definition at line 257 of file fwd.h.

◆ VertexConstraintd_u

using momentum::VertexConstraintd_u = typedef ::std::unique_ptr<VertexConstraintd>

Definition at line 258 of file fwd.h.

◆ VertexConstraintd_w

using momentum::VertexConstraintd_w = typedef ::std::weak_ptr<VertexConstraintd>

Definition at line 259 of file fwd.h.

◆ VertexErrorFunction

using momentum::VertexErrorFunction = typedef VertexErrorFunctionT<float>

Definition at line 877 of file fwd.h.

◆ VertexErrorFunction_const_p

using momentum::VertexErrorFunction_const_p = typedef ::std::shared_ptr<const VertexErrorFunction>

Definition at line 883 of file fwd.h.

◆ VertexErrorFunction_const_u

using momentum::VertexErrorFunction_const_u = typedef ::std::unique_ptr<const VertexErrorFunction>

Definition at line 884 of file fwd.h.

◆ VertexErrorFunction_const_w

using momentum::VertexErrorFunction_const_w = typedef ::std::weak_ptr<const VertexErrorFunction>

Definition at line 885 of file fwd.h.

◆ VertexErrorFunction_p

using momentum::VertexErrorFunction_p = typedef ::std::shared_ptr<VertexErrorFunction>

Definition at line 880 of file fwd.h.

◆ VertexErrorFunction_u

using momentum::VertexErrorFunction_u = typedef ::std::unique_ptr<VertexErrorFunction>

Definition at line 881 of file fwd.h.

◆ VertexErrorFunction_w

using momentum::VertexErrorFunction_w = typedef ::std::weak_ptr<VertexErrorFunction>

Definition at line 882 of file fwd.h.

◆ VertexErrorFunctiond

using momentum::VertexErrorFunctiond = typedef VertexErrorFunctionT<double>

Definition at line 878 of file fwd.h.

◆ VertexErrorFunctiond_const_p

using momentum::VertexErrorFunctiond_const_p = typedef ::std::shared_ptr<const VertexErrorFunctiond>

Definition at line 890 of file fwd.h.

◆ VertexErrorFunctiond_const_u

using momentum::VertexErrorFunctiond_const_u = typedef ::std::unique_ptr<const VertexErrorFunctiond>

Definition at line 891 of file fwd.h.

◆ VertexErrorFunctiond_const_w

using momentum::VertexErrorFunctiond_const_w = typedef ::std::weak_ptr<const VertexErrorFunctiond>

Definition at line 892 of file fwd.h.

◆ VertexErrorFunctiond_p

using momentum::VertexErrorFunctiond_p = typedef ::std::shared_ptr<VertexErrorFunctiond>

Definition at line 887 of file fwd.h.

◆ VertexErrorFunctiond_u

using momentum::VertexErrorFunctiond_u = typedef ::std::unique_ptr<VertexErrorFunctiond>

Definition at line 888 of file fwd.h.

◆ VertexErrorFunctiond_w

using momentum::VertexErrorFunctiond_w = typedef ::std::weak_ptr<VertexErrorFunctiond>

Definition at line 889 of file fwd.h.

◆ VertexProjectionConstraint

using momentum::VertexProjectionConstraint = typedef VertexProjectionConstraintT<float>

Definition at line 266 of file fwd.h.

◆ VertexProjectionConstraint_const_p

using momentum::VertexProjectionConstraint_const_p = typedef ::std::shared_ptr<const VertexProjectionConstraint>

Definition at line 272 of file fwd.h.

◆ VertexProjectionConstraint_const_u

using momentum::VertexProjectionConstraint_const_u = typedef ::std::unique_ptr<const VertexProjectionConstraint>

Definition at line 273 of file fwd.h.

◆ VertexProjectionConstraint_const_w

using momentum::VertexProjectionConstraint_const_w = typedef ::std::weak_ptr<const VertexProjectionConstraint>

Definition at line 274 of file fwd.h.

◆ VertexProjectionConstraint_p

using momentum::VertexProjectionConstraint_p = typedef ::std::shared_ptr<VertexProjectionConstraint>

Definition at line 269 of file fwd.h.

◆ VertexProjectionConstraint_u

using momentum::VertexProjectionConstraint_u = typedef ::std::unique_ptr<VertexProjectionConstraint>

Definition at line 270 of file fwd.h.

◆ VertexProjectionConstraint_w

using momentum::VertexProjectionConstraint_w = typedef ::std::weak_ptr<VertexProjectionConstraint>

Definition at line 271 of file fwd.h.

◆ VertexProjectionConstraintd

using momentum::VertexProjectionConstraintd = typedef VertexProjectionConstraintT<double>

Definition at line 267 of file fwd.h.

◆ VertexProjectionConstraintd_const_p

using momentum::VertexProjectionConstraintd_const_p = typedef ::std::shared_ptr<const VertexProjectionConstraintd>

Definition at line 279 of file fwd.h.

◆ VertexProjectionConstraintd_const_u

using momentum::VertexProjectionConstraintd_const_u = typedef ::std::unique_ptr<const VertexProjectionConstraintd>

Definition at line 280 of file fwd.h.

◆ VertexProjectionConstraintd_const_w

using momentum::VertexProjectionConstraintd_const_w = typedef ::std::weak_ptr<const VertexProjectionConstraintd>

Definition at line 281 of file fwd.h.

◆ VertexProjectionConstraintd_p

using momentum::VertexProjectionConstraintd_p = typedef ::std::shared_ptr<VertexProjectionConstraintd>

Definition at line 276 of file fwd.h.

◆ VertexProjectionConstraintd_u

using momentum::VertexProjectionConstraintd_u = typedef ::std::unique_ptr<VertexProjectionConstraintd>

Definition at line 277 of file fwd.h.

◆ VertexProjectionConstraintd_w

using momentum::VertexProjectionConstraintd_w = typedef ::std::weak_ptr<VertexProjectionConstraintd>

Definition at line 278 of file fwd.h.

◆ VertexProjectionErrorFunction

using momentum::VertexProjectionErrorFunction = typedef VertexProjectionErrorFunctionT<float>

Definition at line 896 of file fwd.h.

◆ VertexProjectionErrorFunction_const_p

using momentum::VertexProjectionErrorFunction_const_p = typedef ::std::shared_ptr<const VertexProjectionErrorFunction>

Definition at line 902 of file fwd.h.

◆ VertexProjectionErrorFunction_const_u

using momentum::VertexProjectionErrorFunction_const_u = typedef ::std::unique_ptr<const VertexProjectionErrorFunction>

Definition at line 904 of file fwd.h.

◆ VertexProjectionErrorFunction_const_w

using momentum::VertexProjectionErrorFunction_const_w = typedef ::std::weak_ptr<const VertexProjectionErrorFunction>

Definition at line 906 of file fwd.h.

◆ VertexProjectionErrorFunction_p

using momentum::VertexProjectionErrorFunction_p = typedef ::std::shared_ptr<VertexProjectionErrorFunction>

Definition at line 899 of file fwd.h.

◆ VertexProjectionErrorFunction_u

using momentum::VertexProjectionErrorFunction_u = typedef ::std::unique_ptr<VertexProjectionErrorFunction>

Definition at line 900 of file fwd.h.

◆ VertexProjectionErrorFunction_w

using momentum::VertexProjectionErrorFunction_w = typedef ::std::weak_ptr<VertexProjectionErrorFunction>

Definition at line 901 of file fwd.h.

◆ VertexProjectionErrorFunctiond

using momentum::VertexProjectionErrorFunctiond = typedef VertexProjectionErrorFunctionT<double>

Definition at line 897 of file fwd.h.

◆ VertexProjectionErrorFunctiond_const_p

using momentum::VertexProjectionErrorFunctiond_const_p = typedef ::std::shared_ptr<const VertexProjectionErrorFunctiond>

Definition at line 911 of file fwd.h.

◆ VertexProjectionErrorFunctiond_const_u

using momentum::VertexProjectionErrorFunctiond_const_u = typedef ::std::unique_ptr<const VertexProjectionErrorFunctiond>

Definition at line 913 of file fwd.h.

◆ VertexProjectionErrorFunctiond_const_w

using momentum::VertexProjectionErrorFunctiond_const_w = typedef ::std::weak_ptr<const VertexProjectionErrorFunctiond>

Definition at line 915 of file fwd.h.

◆ VertexProjectionErrorFunctiond_p

using momentum::VertexProjectionErrorFunctiond_p = typedef ::std::shared_ptr<VertexProjectionErrorFunctiond>

Definition at line 908 of file fwd.h.

◆ VertexProjectionErrorFunctiond_u

using momentum::VertexProjectionErrorFunctiond_u = typedef ::std::unique_ptr<VertexProjectionErrorFunctiond>

Definition at line 909 of file fwd.h.

◆ VertexProjectionErrorFunctiond_w

using momentum::VertexProjectionErrorFunctiond_w = typedef ::std::weak_ptr<VertexProjectionErrorFunctiond>

Definition at line 910 of file fwd.h.

◆ VertexSequenceErrorFunction

using momentum::VertexSequenceErrorFunction = typedef VertexSequenceErrorFunctionT<float>

Definition at line 183 of file fwd.h.

◆ VertexSequenceErrorFunction_const_p

using momentum::VertexSequenceErrorFunction_const_p = typedef ::std::shared_ptr<const VertexSequenceErrorFunction>

Definition at line 189 of file fwd.h.

◆ VertexSequenceErrorFunction_const_u

using momentum::VertexSequenceErrorFunction_const_u = typedef ::std::unique_ptr<const VertexSequenceErrorFunction>

Definition at line 190 of file fwd.h.

◆ VertexSequenceErrorFunction_const_w

using momentum::VertexSequenceErrorFunction_const_w = typedef ::std::weak_ptr<const VertexSequenceErrorFunction>

Definition at line 191 of file fwd.h.

◆ VertexSequenceErrorFunction_p

using momentum::VertexSequenceErrorFunction_p = typedef ::std::shared_ptr<VertexSequenceErrorFunction>

Definition at line 186 of file fwd.h.

◆ VertexSequenceErrorFunction_u

using momentum::VertexSequenceErrorFunction_u = typedef ::std::unique_ptr<VertexSequenceErrorFunction>

Definition at line 187 of file fwd.h.

◆ VertexSequenceErrorFunction_w

using momentum::VertexSequenceErrorFunction_w = typedef ::std::weak_ptr<VertexSequenceErrorFunction>

Definition at line 188 of file fwd.h.

◆ VertexSequenceErrorFunctiond

using momentum::VertexSequenceErrorFunctiond = typedef VertexSequenceErrorFunctionT<double>

Definition at line 184 of file fwd.h.

◆ VertexSequenceErrorFunctiond_const_p

using momentum::VertexSequenceErrorFunctiond_const_p = typedef ::std::shared_ptr<const VertexSequenceErrorFunctiond>

Definition at line 196 of file fwd.h.

◆ VertexSequenceErrorFunctiond_const_u

using momentum::VertexSequenceErrorFunctiond_const_u = typedef ::std::unique_ptr<const VertexSequenceErrorFunctiond>

Definition at line 197 of file fwd.h.

◆ VertexSequenceErrorFunctiond_const_w

using momentum::VertexSequenceErrorFunctiond_const_w = typedef ::std::weak_ptr<const VertexSequenceErrorFunctiond>

Definition at line 198 of file fwd.h.

◆ VertexSequenceErrorFunctiond_p

using momentum::VertexSequenceErrorFunctiond_p = typedef ::std::shared_ptr<VertexSequenceErrorFunctiond>

Definition at line 193 of file fwd.h.

◆ VertexSequenceErrorFunctiond_u

using momentum::VertexSequenceErrorFunctiond_u = typedef ::std::unique_ptr<VertexSequenceErrorFunctiond>

Definition at line 194 of file fwd.h.

◆ VertexSequenceErrorFunctiond_w

using momentum::VertexSequenceErrorFunctiond_w = typedef ::std::weak_ptr<VertexSequenceErrorFunctiond>

Definition at line 195 of file fwd.h.

◆ VertexVertexDistanceErrorFunction

using momentum::VertexVertexDistanceErrorFunction = typedef VertexVertexDistanceErrorFunctionT<float>

Definition at line 920 of file fwd.h.

◆ VertexVertexDistanceErrorFunction_const_p

using momentum::VertexVertexDistanceErrorFunction_const_p = typedef ::std::shared_ptr<const VertexVertexDistanceErrorFunction>

Definition at line 926 of file fwd.h.

◆ VertexVertexDistanceErrorFunction_const_u

using momentum::VertexVertexDistanceErrorFunction_const_u = typedef ::std::unique_ptr<const VertexVertexDistanceErrorFunction>

Definition at line 928 of file fwd.h.

◆ VertexVertexDistanceErrorFunction_const_w

using momentum::VertexVertexDistanceErrorFunction_const_w = typedef ::std::weak_ptr<const VertexVertexDistanceErrorFunction>

Definition at line 930 of file fwd.h.

◆ VertexVertexDistanceErrorFunction_p

using momentum::VertexVertexDistanceErrorFunction_p = typedef ::std::shared_ptr<VertexVertexDistanceErrorFunction>

Definition at line 923 of file fwd.h.

◆ VertexVertexDistanceErrorFunction_u

using momentum::VertexVertexDistanceErrorFunction_u = typedef ::std::unique_ptr<VertexVertexDistanceErrorFunction>

Definition at line 924 of file fwd.h.

◆ VertexVertexDistanceErrorFunction_w

using momentum::VertexVertexDistanceErrorFunction_w = typedef ::std::weak_ptr<VertexVertexDistanceErrorFunction>

Definition at line 925 of file fwd.h.

◆ VertexVertexDistanceErrorFunctiond

using momentum::VertexVertexDistanceErrorFunctiond = typedef VertexVertexDistanceErrorFunctionT<double>

Definition at line 921 of file fwd.h.

◆ VertexVertexDistanceErrorFunctiond_const_p

using momentum::VertexVertexDistanceErrorFunctiond_const_p = typedef ::std::shared_ptr<const VertexVertexDistanceErrorFunctiond>

Definition at line 936 of file fwd.h.

◆ VertexVertexDistanceErrorFunctiond_const_u

using momentum::VertexVertexDistanceErrorFunctiond_const_u = typedef ::std::unique_ptr<const VertexVertexDistanceErrorFunctiond>

Definition at line 938 of file fwd.h.

◆ VertexVertexDistanceErrorFunctiond_const_w

using momentum::VertexVertexDistanceErrorFunctiond_const_w = typedef ::std::weak_ptr<const VertexVertexDistanceErrorFunctiond>

Definition at line 940 of file fwd.h.

◆ VertexVertexDistanceErrorFunctiond_p

using momentum::VertexVertexDistanceErrorFunctiond_p = typedef ::std::shared_ptr<VertexVertexDistanceErrorFunctiond>

Definition at line 933 of file fwd.h.

◆ VertexVertexDistanceErrorFunctiond_u

using momentum::VertexVertexDistanceErrorFunctiond_u = typedef ::std::unique_ptr<VertexVertexDistanceErrorFunctiond>

Definition at line 934 of file fwd.h.

◆ VertexVertexDistanceErrorFunctiond_w

using momentum::VertexVertexDistanceErrorFunctiond_w = typedef ::std::weak_ptr<VertexVertexDistanceErrorFunctiond>

Definition at line 935 of file fwd.h.

◆ WeightMatrix

using momentum::WeightMatrix = typedef Eigen::Matrix<float, Eigen::Dynamic, kMaxSkinJoints, Eigen::AutoAlign | Eigen::RowMajor>

Matrix type for storing weights of joint influences on each vertex.

Each row represents a vertex, and each column represents the weight of a joint influence. The matrix has a fixed number of columns (kMaxSkinJoints) and a dynamic number of rows.

Definition at line 32 of file skin_weights.h.

Enumeration Type Documentation

◆ CharacterFormat

enum class momentum::CharacterFormat : uint8_t

strong

Represents the supported character formats.

Enumerator
Fbx	FBX file format.
Gltf	glTF file format.
Usd	USD file format.
Unknown	Unknown or unsupported file format.

Definition at line 23 of file character_io.h.

◆ EulerConvention

enum class momentum::EulerConvention

strong

The Euler angles convention.

Enumerator

Intrinsic

The intrinsic convention.

Intrinsic rotations (also called local, relative, or body-fixed rotations) are performed around the axes of the coordinate system that is attached to the rotating object.

Intrinsic rotations are usually represented by a sequence of three letters, like XYZ, which means rotation around the X-axis, followed by rotation around the Y-axis, and finally rotation around the Z-axis. For example, intrinsic XYZ is equivalent to RotX(a) * RotY(b) * RotZ(c).

Extrinsic

The extrinsic convention.

Extrinsic rotations (also called global, absolute, or space-fixed rotations) are performed around the axes of a fixed coordinate system.

Extrinsic rotations are often represented by uppercase letters, like XYZ, which means rotation around the fixed X-axis, followed by rotation around the fixed Y-axis, and finally rotation around the fixed Z-axis. For example, extrinsic XYZ is equivalent to RotZ(c) * RotY(b) * RotX(a).

Definition at line 136 of file utility.h.

◆ FbxCoordSystem

enum class momentum::FbxCoordSystem

strong

Specifies the third vector of the system.

Maps to fbxsdk::FbxAxisSystem::ECoordSystem

Enumerator
RightHanded
LeftHanded

Definition at line 42 of file file_save_options.h.

◆ FbxFrontVector

enum class momentum::FbxFrontVector

strong

Vector with origin at the screen pointing toward the camera.

This is a subset of enum EUpVector because axis cannot be repeated. We use the system of "parity" to define this vector because its value (X,Y or Z axis) really depends on the up-vector. Maps to fbxsdk::FbxAxisSystem::EFrontVector

Enumerator
ParityEven
ParityOdd

Definition at line 38 of file file_save_options.h.

◆ FbxUpVector

enum class momentum::FbxUpVector

strong

Specifies which canonical axis represents up in the system (typically Y or Z).

Maps to fbxsdk::FbxAxisSystem::EUpVector

Enumerator
XAxis
YAxis
ZAxis

Definition at line 31 of file file_save_options.h.

◆ GltfFileFormat

enum class momentum::GltfFileFormat

strong

File format in which the character is saved.

Enumerator
Auto
Binary
Ascii

Definition at line 19 of file file_save_options.h.

◆ JointParameterNames

enum momentum::JointParameterNames

Enumerator
TX
TY
TZ
RX
RY
RZ
SC

Definition at line 26 of file types.h.

◆ KeepLocators

enum class momentum::KeepLocators

strong

Enumerator
No
Yes

Definition at line 23 of file fbx_io.h.

◆ LimitType

enum momentum::LimitType

Enumerator
MinMax
MinMaxJoint
MinMaxJointPassive
Linear
LinearJoint
Ellipsoid
HalfPlane
LimitTypeCount

Definition at line 20 of file parameter_limits.h.

◆ LoadBlendShapes

enum class momentum::LoadBlendShapes

strong

Enumerator
No
Yes

Definition at line 26 of file fbx_io.h.

◆ LocatorSpace

enum class momentum::LocatorSpace

strong

Enumerator
Local
Global

Definition at line 18 of file locator_io.h.

◆ LogLevel

enum class momentum::LogLevel

strong

Logging levels in descending order of verbosity.

Enumerator
Disabled
Error
Warning
Info
Debug
Trace

Definition at line 156 of file log.h.

◆ RotationErrorType

enum class momentum::RotationErrorType

strong

Defines different methods for computing rotation error between two quaternions.

Enumerator

RotationMatrixDifference

Frobenius norm of rotation matrix difference: ||R1 - R2||_F^2.

This is the default method. It computes the squared Frobenius norm of the difference between two rotation matrices. While not a geodesic distance, it has smooth derivatives everywhere and is computationally efficient.

QuaternionLogMap

Logarithmic map of relative rotation: ||log(R1^{-1} * R2)||^2.

This method computes the squared norm of the logarithmic map of the relative rotation quaternion. This gives the squared geodesic distance on SO(3), which has a clear geometric interpretation. It uses numerically robust logmap computation with Taylor series for small angles.

Definition at line 17 of file state_error_function.h.

◆ Unit

enum class momentum::Unit

strong

An enumeration representing the units of measurement used in marker data files.

Enumerator
M	Meters.
DM	Decimeter.
CM	Centimeters.
MM	Millimeters.
Unknown	Unknown unit of measurement.

Definition at line 22 of file coordinate_system.h.

◆ UpVector

enum class momentum::UpVector

strong

This enumeration is used to define the primary up vector directions for various coordinate systems and orientations in a 3D environment.

Enumerator
X	X-axis up vector.
Y	Y-axis up vector.
Z	Z-axis up vector.
YNeg	Negative Y-axis up vector.

Definition at line 14 of file coordinate_system.h.

◆ VertexConstraintType

enum class momentum::VertexConstraintType

strong

Enumerator
Position
Plane
Normal
SymmetricNormal

Definition at line 35 of file vertex_error_function.h.

Function Documentation

◆ addBlendShapeParameters()

std::tuple< ParameterTransform, ParameterLimits > momentum::addBlendShapeParameters	(	ParameterTransform	paramTransform,
		ParameterLimits	paramLimits,
		Eigen::Index	nBlendShapes
	)

Definition at line 563 of file parameter_transform.cpp.

References subsetParameterTransform().

Referenced by momentum::CharacterT< T >::addBlendShape().

◆ addCalibrationOptions()

void momentum::addCalibrationOptions	(	CLI::App &	app,
		std::shared_ptr< CalibrationConfig >	config
	)

Definition at line 44 of file app_utils.cpp.

◆ addFaceExpressionParameters()

std::tuple< ParameterTransform, ParameterLimits > momentum::addFaceExpressionParameters	(	ParameterTransform	paramTransform,
		ParameterLimits	paramLimits,
		Eigen::Index	nFaceExpressionBlendShapes
	)

Definition at line 588 of file parameter_transform.cpp.

References subsetParameterTransform().

Referenced by momentum::CharacterT< T >::addFaceExpressionBlendShape().

◆ addIOOptions()

void momentum::addIOOptions	(	CLI::App &	app,
		std::shared_ptr< IOOptions >	ioOptions
	)

Definition at line 26 of file app_utils.cpp.

◆ addModelOptions()

void momentum::addModelOptions	(	CLI::App &	app,
		std::shared_ptr< ModelOptions >	modelOptions
	)

Definition at line 35 of file app_utils.cpp.

◆ addRefineOptions()

void momentum::addRefineOptions	(	CLI::App &	app,
		std::shared_ptr< RefineConfig >	config
	)

Definition at line 131 of file app_utils.cpp.

References addTrackingOptions().

◆ addSkinnedLocatorParameters()

std::tuple< ParameterTransform, ParameterLimits > momentum::addSkinnedLocatorParameters	(	ParameterTransform	paramTransform,
		ParameterLimits	paramLimits,
		const std::vector< bool > &	activeLocators,
		const std::vector< std::string > &	locatorNames = `{}`
	)

Add a set of parameters that control the rest-space positions of the skinned locators.

This function will add 3 parameters for each locator, one for each of the x, y, and z components of the locator position. The parameters are added to the end of the parameter transform. The parameter transform is returned along with the updated list of parameter limits. Note that you pass in the locator names rather than the actual SkinnedLocator objects because this avoids a circular dependency.

Definition at line 613 of file parameter_transform.cpp.

References MT_CHECK, and subsetParameterTransform().

Referenced by addSkinnedLocatorParametersToTransform().

◆ addSkinnedLocatorParametersToTransform()

Character momentum::addSkinnedLocatorParametersToTransform ( Character character )

Definition at line 698 of file marker_tracker.cpp.

References addSkinnedLocatorParameters(), momentum::CharacterT< T >::parameterLimits, momentum::CharacterT< T >::parameterTransform, and momentum::CharacterT< T >::skinnedLocators.

Referenced by calibrateModel().

◆ addTrackingOptions()

void momentum::addTrackingOptions	(	CLI::App &	app,
		std::shared_ptr< TrackingConfig >	config
	)

Definition at line 100 of file app_utils.cpp.

Referenced by addRefineOptions().

◆ aligned_free()

void momentum::aligned_free ( void * ptr )

inline

Definition at line 46 of file aligned.h.

Referenced by momentum::AlignedAllocator< T, Alignment >::deallocate(), and momentum::AlignedDeleter::operator()().

◆ aligned_malloc()

void * momentum::aligned_malloc	(	size_t	size,
		size_t	align
	)

inline

Definition at line 42 of file aligned.h.

Referenced by alignedAlloc().

◆ alignedAlloc()

template<typename T , std::size_t Alignment = alignof(T)>

T * momentum::alignedAlloc ( std::size_t n )

Allocates a block of memory that can hold n elements of type T with the specified alignment.

This function is intended to be used in the AlignedAllocator::allocate() method and throws exceptions as std::allocator<T>::allocate does.

Definition at line 62 of file aligned.h.

References aligned_malloc(), MT_THROW_IF_T, and roundUpToAlignment().

◆ allParams()

ParameterSet momentum::allParams ( )

inline

Creates a ParameterSet with all parameters set to active.

Definition at line 37 of file utility.h.

Referenced by momentum::SequenceSolverFunctionT< T >::SequenceSolverFunctionT().

◆ applyInverseSSD() [1/2]

std::vector< Vector3f > momentum::applyInverseSSD	(	const TransformationList &	inverseBindPose,
		const SkinWeights &	skin,
		std::span< const Vector3f >	points,
		const SkeletonState &	state
	)

Applies inverse SSD to points, returning new points in bind pose space.

This overload transforms points from skinned space back to bind pose space, returning a new vector of transformed points.

Parameters

inverseBindPose	Inverse bind pose transformations for each joint
skin	Skin weights defining influence of each joint on vertices
points	Input points to transform (in skinned space)
state	Current skeleton state containing joint transformations

Returns: Vector of transformed points in bind pose space

Definition at line 259 of file linear_skinning.cpp.

References applyInverseSSD(), and MT_CHECK.

◆ applyInverseSSD() [2/2]

void momentum::applyInverseSSD	(	const TransformationList &	inverseBindPose,
		const SkinWeights &	skin,
		std::span< const Vector3f >	points,
		const SkeletonState &	state,
		Mesh &	mesh
	)

Applies inverse SSD to points, storing results in a mesh.

This overload transforms points from skinned space back to bind pose space, writing the results directly to the provided mesh's vertices.

Parameters

inverseBindPose	Inverse bind pose transformations for each joint
skin	Skin weights defining influence of each joint on vertices
points	Input points to transform (in skinned space)
state	Current skeleton state containing joint transformations
mesh	Output mesh to store the transformed vertices

Definition at line 247 of file linear_skinning.cpp.

References applyInverseSSD(), MT_CHECK, and momentum::MeshT< T >::vertices.

Referenced by applyInverseSSD(), and applyInverseSSD().

◆ applyPassiveJointParameterLimits()

JointParameters momentum::applyPassiveJointParameterLimits	(	const ParameterLimits &	limits,
		const JointParameters &	jointParams
	)

Only processes MinMaxJointPassive limits, clamping parameters to their ranges.

Definition at line 39 of file parameter_limits.cpp.

References kParametersPerJoint, limits, MinMaxJointPassive, and MT_CHECK.

Referenced by momentum::CharacterStateT< T >::set().

◆ applySSD() [1/3]

template<typename T >

void momentum::applySSD	(	const TransformationListT< T > &	inverseBindPose,
		const SkinWeights &	skin,
		const MeshT< T > &	mesh,
		const JointStateListT< T > &	state,
		MeshT< T > &	outputMesh
	)

Applies forward SSD to a mesh using raw joint state list, modifying output mesh.

This overload accepts a JointStateList directly instead of a full SkeletonState. Use this when you have joint transformations but not a complete skeleton state.

Parameters

inverseBindPose	Inverse bind pose transformations for each joint
skin	Skin weights defining influence of each joint on vertices
mesh	Input mesh to transform
state	List of joint states containing transformations
outputMesh	Output mesh to store the transformed result

Definition at line 107 of file linear_skinning.cpp.

References applySSD(), momentum::MeshT< T >::faces, MT_CHECK, MT_PROFILE_FUNCTION, momentum::MeshT< T >::normals, and momentum::MeshT< T >::vertices.

◆ applySSD() [2/3]

template<typename T >

void momentum::applySSD	(	const TransformationListT< T > &	inverseBindPose,
		const SkinWeights &	skin,
		const MeshT< T > &	mesh,
		const SkeletonStateT< T > &	state,
		MeshT< T > &	outputMesh
	)

Applies forward SSD to a mesh using skeleton state, modifying output mesh.

This overload transforms both vertices and normals of the mesh, writing results to outputMesh. Use this when working with complete meshes and full skeleton state.

Parameters

inverseBindPose	Inverse bind pose transformations for each joint
skin	Skin weights defining influence of each joint on vertices
mesh	Input mesh to transform
state	Current skeleton state containing joint transformations
outputMesh	Output mesh to store the transformed result

Definition at line 97 of file linear_skinning.cpp.

References applySSD().

◆ applySSD() [3/3]

template<typename T >

std::vector< Vector3< T > > momentum::applySSD	(	const TransformationListT< T > &	inverseBindPose,
		const SkinWeights &	skin,
		typename DeduceSpanType< const Vector3< T > >::type	points,
		const SkeletonStateT< T > &	state
	)

Applies forward SSD (linear blend skinning) to points, returning new points.

This overload transforms individual points and returns a new vector of transformed points. Use this when you need to transform arbitrary points without modifying a mesh.

Parameters

inverseBindPose	Inverse bind pose transformations for each joint
skin	Skin weights defining influence of each joint on vertices
points	Input points to transform
state	Current skeleton state containing joint transformations

Returns: Vector of transformed points

Definition at line 22 of file linear_skinning.cpp.

References MT_CHECK, and MT_PROFILE_FUNCTION.

Referenced by applySSD(), applySSD(), momentum::CharacterT< T >::bake(), momentum::CharacterStateT< T >::set(), and momentum::MeshStateT< T >::update().

◆ applySSD< double >() [1/3]

template void momentum::applySSD< double >	(	const TransformationListT< double > &	inverseBindPose,
		const SkinWeights &	skin,
		const MeshT< double > &	mesh,
		const JointStateListT< double > &	jointState,
		MeshT< double > &	outputMesh
	)

◆ applySSD< double >() [2/3]

template void momentum::applySSD< double >	(	const TransformationListT< double > &	inverseBindPose,
		const SkinWeights &	skin,
		const MeshT< double > &	mesh,
		const SkeletonStateT< double > &	jointState,
		MeshT< double > &	outputMesh
	)

◆ applySSD< double >() [3/3]

template std::vector< Vector3d > momentum::applySSD< double >	(	const TransformationListT< double > &	inverseBindPose,
		const SkinWeights &	skin,
		typename DeduceSpanType< const Vector3< double > >::type	points,
		const SkeletonStateT< double > &	state
	)

◆ applySSD< float >() [1/3]

template void momentum::applySSD< float >	(	const TransformationList &	inverseBindPose,
		const SkinWeights &	skin,
		const MeshT< float > &	mesh,
		const SkeletonStateT< float > &	jointState,
		MeshT< float > &	outputMesh
	)

◆ applySSD< float >() [2/3]

template void momentum::applySSD< float >	(	const TransformationListT< float > &	inverseBindPose,
		const SkinWeights &	skin,
		const MeshT< float > &	mesh,
		const JointStateListT< float > &	jointState,
		MeshT< float > &	outputMesh
	)

◆ applySSD< float >() [3/3]

template std::vector< Vector3f > momentum::applySSD< float >	(	const TransformationListT< float > &	inverseBindPose,
		const SkinWeights &	skin,
		typename DeduceSpanType< const Vector3< float > >::type	points,
		const SkeletonStateT< float > &	state
	)

◆ averageTriangleSkinWeights()

std::pair< Eigen::Vector< uint32_t, kMaxSkinJoints >, Eigen::Vector< float, kMaxSkinJoints > > momentum::averageTriangleSkinWeights	(	const Character &	character,
		int	triangleIndex,
		const Eigen::Vector3f &	barycentric
	)

Definition at line 100 of file tracker_utils.cpp.

References momentum::SkeletonT< T >::joints, momentum::CharacterT< T >::mesh, momentum::CharacterT< T >::skeleton, and momentum::CharacterT< T >::skinWeights.

Referenced by locatorsToSkinnedLocators().

◆ blendTransforms() [1/3]

template TransformT< double > momentum::blendTransforms	(	std::span< const TransformT< double > >	transforms,
		std::span< const double >	weights
	)

◆ blendTransforms() [2/3]

template TransformT< float > momentum::blendTransforms	(	std::span< const TransformT< float > >	transforms,
		std::span< const float >	weights
	)

◆ blendTransforms() [3/3]

template<typename T >

TransformT< T > momentum::blendTransforms	(	std::span< const TransformT< T > >	transforms,
		std::span< const T >	weights
	)

Definition at line 96 of file transform.cpp.

◆ buildJetMat()

template<typename T , int Rows, int Cols>

Eigen::Matrix< ceres::Jet< T, Cols *Rows >, Rows, Cols > momentum::buildJetMat ( const Eigen::Matrix< T, Rows, Cols > & m )

Definition at line 43 of file ceres_utility.h.

◆ buildJetVec()

template<typename T , int N>

Eigen::Matrix< ceres::Jet< T, N >, N, 1 > momentum::buildJetVec ( const Eigen::Matrix< T, N, 1 > & v )

Definition at line 31 of file ceres_utility.h.

◆ calculateDWorldPos()

template<typename T >

Eigen::Vector3< T > momentum::calculateDWorldPos	(	const momentum::Character &	character,
		const SkeletonStateT< T > &	state,
		const int	vertexIndex,
		const Eigen::Vector3< T > &	d_restPos
	)

Definition at line 192 of file point_triangle_vertex_error_function.cpp.

References momentum::CharacterT< T >::inverseBindPose, and momentum::CharacterT< T >::skinWeights.

◆ calibrateLocators() [1/2]

void momentum::calibrateLocators	(	const std::span< const std::vector< Marker > >	markerData,
		const CalibrationConfig &	config,
		const ModelParameters &	identity,
		Character &	character
	)

Calibrate only locator positions with fixed character identity parameters.

This is a specialized calibration function that only solves for locator positions while keeping all other character parameters (scaling, blend shapes) fixed. This is useful when you have reliable identity parameters and only need to fine-tune marker positions.

Parameters

markerData	Marker observations for each frame
config	Calibration configuration settings
identity	Fixed identity parameters (scaling, blend shapes)
character	Character model to calibrate (locators modified in-place)

Definition at line 967 of file marker_tracker.cpp.

References createLocatorCharacter(), extractLocatorsFromCharacter(), momentum::CharacterT< T >::locators, momentum::BaseConfig::minVisPercent, MT_CHECK, MT_LOGI_IF, momentum::ParameterTransformT< T >::numAllModelParameters(), momentum::ParameterTransformT< T >::parameterSets, momentum::CharacterT< T >::parameterTransform, sampleFrames(), trackPosesForFrames(), trackPosesPerframe(), trackSequence(), and momentum::EigenStrongType< Derived, EigenType >::v.

Referenced by processMarkers().

◆ calibrateLocators() [2/2]

void momentum::calibrateLocators	(	std::span< const std::vector< momentum::Marker > >	markerData,
		const CalibrationConfig &	config,
		const momentum::ModelParameters &	identity,
		momentum::Character &	character
	)

Calibrate locator offsets of a character from input identity and marker data.

Parameters

[in]	markerData	Input marker data.
[in]	config	Solving options.
[in]	identity	Identity parameters of the input character.
[in,out]	character	Character definition. It provides input locators offsets which will get updated in return. We overwrite the locators in the input character so we don't have to duplicate the character object inside the function.

◆ calibrateModel() [1/2]

void momentum::calibrateModel	(	const std::span< const std::vector< Marker > >	markerData,
		const CalibrationConfig &	config,
		Character &	character,
		ModelParameters &	identity
	)

Calibrate character identity parameters (scaling, locators, blend shapes) from marker data.

This is the main calibration function that solves for global character parameters that remain constant across all frames. It uses a multi-stage approach:

Initialize poses with fixed identity
Alternate between solving global parameters and poses
Fine-tune locator positions

Parameters

markerData	Marker observations for each frame
config	Calibration configuration settings
character	Character model to calibrate (modified in-place)
identity	Output identity parameters (scaling, blend shapes)

Definition at line 725 of file marker_tracker.cpp.

References addSkinnedLocatorParametersToTransform(), createLocatorCharacter(), extractBlendShapeFromParams(), extractIdAndLocatorsFromParams(), momentum::ParameterTransformT< T >::getBlendShapeParameters(), momentum::ParameterTransformT< T >::getParameterIdByName(), momentum::ParameterTransformT< T >::getParameterSet(), momentum::ParameterTransformT< T >::getScalingParameters(), kInvalidIndex, momentum::CharacterT< T >::locators, momentum::CharacterT< T >::mesh, momentum::BaseConfig::minVisPercent, MT_CHECK, MT_LOGI_IF, MT_THROW_IF, momentum::ParameterTransformT< T >::numAllModelParameters(), momentum::CharacterT< T >::parameterTransform, sampleFrames(), momentum::CharacterT< T >::skinnedLocators, trackPosesForFrames(), trackPosesPerframe(), trackSequence(), and momentum::EigenStrongType< Derived, EigenType >::v.

Referenced by processMarkers().

◆ calibrateModel() [2/2]

void momentum::calibrateModel	(	std::span< const std::vector< momentum::Marker > >	markerData,
		const CalibrationConfig &	config,
		momentum::Character &	character,
		momentum::ModelParameters &	identity
	)

Calibrate body proportions and locator offsets of a character from input marker data.

Parameters

[in]	markerData	Input marker data.
[in]	config	Solving options.
[in,out]	character	Character definition. It provides input locators offsets which will get updated in return.
[in,out]	identity	Initial identity parameters that get updated in return. It could also hold the pose of the first frame for better initialization for tracking later.

◆ cast()

template<typename OtherScalar , template< typename... > class ContainerType, typename ObjectType >

decltype(auto) momentum::cast ( const ContainerType< ObjectType > & originalContainer )

Casts the scalar type of objects in a container that support the cast<>() method.

Template Parameters

OtherScalar	The target scalar type for the cast.
ContainerType	The type of the container.
ObjectType	The type of the objects in the original container.

Parameters

originalContainer A container of objects.

Returns: A new container with objects of the scalar type casted to OtherScalar. If OtherScalar matches the original type, the original container is returned.

Definition at line 438 of file types.h.

◆ cast_span() [1/2]

template<typename T >

std::span< const T > momentum::cast_span ( std::span< const std::byte > bs )

Casts a span of const bytes to a span of a different type.

This function takes a span of const bytes and returns a span of a different type, by reinterpreting the bytes as the new type. This function is useful when working with serialized data or when dealing with raw memory. The function assumes that the size of the new type is an exact multiple of the size of the original span.

Template Parameters

T	The type to cast the span to

Parameters

bs	The original span of const bytes to cast

Returns: A span of the new type, with the same number of elements as the original span

Definition at line 44 of file gsl_utils.h.

◆ cast_span() [2/2]

template<typename T >

std::span< T > momentum::cast_span ( std::span< std::byte > bs )

Casts a span of bytes to a span of a different type.

This function takes a span of bytes and returns a span of a different type, by reinterpreting the bytes as the new type. This function is useful when working with serialized data or when dealing with raw memory. The function assumes that the size of the new type is an exact multiple of the size of the original span.

Template Parameters

T	The type to cast the span to

Parameters

bs	The original span of bytes to cast

Returns: A span of the new type, with the same number of elements as the original span

Definition at line 26 of file gsl_utils.h.

◆ castMatrices()

template<typename T , typename T2 >

std::vector< Eigen::MatrixX< T2 > > momentum::castMatrices ( std::span< const Eigen::MatrixX< T > > m_in )

Definition at line 58 of file mppca.cpp.

◆ castVectors()

template<typename T , typename T2 , int N>

std::vector< Eigen::Vector< T2, N > > momentum::castVectors ( const std::vector< Eigen::Vector< T, N > > & vec_in )

Definition at line 50 of file mesh.cpp.

◆ characterToLegacyJson()

nlohmann::json momentum::characterToLegacyJson ( const Character & character )

Converts a Character to legacy JSON object.

Parameters

[in] character The Character to convert

Returns: nlohmann::json object containing the legacy JSON representation

Definition at line 580 of file legacy_json_io.cpp.

References momentum::CharacterT< T >::collision, momentum::CharacterT< T >::locators, momentum::CharacterT< T >::mesh, momentum::CharacterT< T >::skeleton, and momentum::CharacterT< T >::skinWeights.

Referenced by characterToLegacyJsonString(), and saveCharacterToLegacyJson().

◆ characterToLegacyJsonString()

std::string momentum::characterToLegacyJsonString ( const Character & character )

Converts a Character to legacy JSON string.

Parameters

[in] character The Character to convert

Returns: String containing the legacy JSON representation

Definition at line 575 of file legacy_json_io.cpp.

References characterToLegacyJson().

◆ checkAlignment()

template<size_t Alignment>

void momentum::checkAlignment	(	const Eigen::Ref< Eigen::MatrixXf > &	mat,
		size_t	offset = `0`
	)

Checks if the data of the matrix is aligned correctly.

Definition at line 76 of file simd.h.

References MT_THROW_IF.

◆ closestPointOnMeshMatchingParent()

ClosestPointOnMeshResult momentum::closestPointOnMeshMatchingParent	(	const momentum::Mesh &	mesh,
		const momentum::SkinWeights &	skin,
		const Eigen::Vector3f &	p_world,
		uint32_t	parentIdx,
		float	cutoffWeight = `0.1`
	)

Definition at line 153 of file tracker_utils.cpp.

References momentum::MeshT< T >::faces, and momentum::MeshT< T >::vertices.

Referenced by createSkinnedLocatorMeshConstraints(), and locatorsToSkinnedLocators().

◆ closestPointsOnSegments()

template<typename T >

std::tuple< bool, T, Eigen::Vector2< T > > momentum::closestPointsOnSegments	(	const Eigen::Vector3< T > &	o1,
		const Eigen::Vector3< T > &	d1,
		const Eigen::Vector3< T > &	o2,
		const Eigen::Vector3< T > &	d2,
		T	maxDist = `std::numeric_limits< T >::max()`
	)

Returns the closest points on two line segments where the line segments are represented in origin and direction.

Template Parameters

T	Scalar type

Parameters

o1	Origin of the first line segment
d1	Direction of the first line segment
o2	Origin of the second line segment
d2	Direction of the second line segment
maxDist	Maximum distance to check

Returns

[success, distance, [dist0, dist1]]:

success: Whether the closest points were successfully found. On false, the rest return values are invalid.
distance: Distance between the closest points
[dist0, dist1]: Distances of the closest points from their origins to the directions

Definition at line 434 of file utility.cpp.

References distance.

◆ closestPointsOnSegments< double >()

template std::tuple< bool, double, Eigen::Vector2< double > > momentum::closestPointsOnSegments< double >	(	const Eigen::Vector3< double > &	o1,
		const Eigen::Vector3< double > &	d1,
		const Eigen::Vector3< double > &	o2,
		const Eigen::Vector3< double > &	d2,
		const double	maxDist
	)

◆ closestPointsOnSegments< float >()

template std::tuple< bool, float, Eigen::Vector2< float > > momentum::closestPointsOnSegments< float >	(	const Eigen::Vector3< float > &	o1,
		const Eigen::Vector3< float > &	d1,
		const Eigen::Vector3< float > &	o2,
		const Eigen::Vector3< float > &	d2,
		const float	maxDist
	)

◆ compute_d_targetNormal_d_vertexPos() [1/2]

template<typename T >

std::array< Eigen::Matrix3< T >, 3 > momentum::compute_d_targetNormal_d_vertexPos	(	const PointTriangleVertexConstraintT< T > &	cons,
		const MeshT< T > &	mesh
	)

Definition at line 343 of file point_triangle_vertex_error_function.cpp.

References cross(), and momentum::MeshT< T >::vertices.

Referenced by compute_d_targetPos_d_vertexPos(), and compute_d_targetPos_d_vertexPos().

◆ compute_d_targetNormal_d_vertexPos() [2/2]

template<typename T >

std::array< Eigen::Matrix3< T >, 3 > momentum::compute_d_targetNormal_d_vertexPos	(	const SkinnedLocatorTriangleConstraintT< T > &	cons,
		const MeshT< T > &	mesh
	)

Definition at line 108 of file skinned_locator_triangle_error_function.cpp.

References cross(), and momentum::MeshT< T >::vertices.

◆ compute_d_targetPos_d_vertexPos() [1/2]

template<typename T >

std::array< Eigen::Matrix3< T >, 3 > momentum::compute_d_targetPos_d_vertexPos	(	const PointTriangleVertexConstraintT< T > &	cons,
		const MeshT< T > &	mesh
	)

Definition at line 378 of file point_triangle_vertex_error_function.cpp.

References compute_d_targetNormal_d_vertexPos().

◆ compute_d_targetPos_d_vertexPos() [2/2]

template<typename T >

std::array< Eigen::Matrix3< T >, 3 > momentum::compute_d_targetPos_d_vertexPos	(	const SkinnedLocatorTriangleConstraintT< T > &	cons,
		const MeshT< T > &	mesh
	)

Definition at line 143 of file skinned_locator_triangle_error_function.cpp.

References compute_d_targetNormal_d_vertexPos().

◆ computeOffset()

template<size_t Alignment>

size_t momentum::computeOffset ( const Eigen::Ref< Eigen::MatrixXf > & mat )

Computes the offset required for the matrix data to meet the alignment requirement.

Definition at line 61 of file simd.h.

◆ computeSubsetParameterIndices()

template<typename T >

std::vector< Eigen::Index > momentum::computeSubsetParameterIndices	(	const ParameterTransformT< T > &	parameterTransform,
		const ParameterSet &	activeParams
	)

Definition at line 21 of file fully_differentiable_body_ik.cpp.

References momentum::ParameterTransformT< T >::numAllModelParameters(), and parameterTransform.

Referenced by d_modelParams_d_inputs().

◆ computeTargetBaryPosition() [1/2]

template<typename T >

Eigen::Vector3< T > momentum::computeTargetBaryPosition	(	const MeshT< T > &	mesh,
		const PointTriangleVertexConstraintT< T > &	c
	)

Definition at line 71 of file point_triangle_vertex_error_function.cpp.

References momentum::MeshT< T >::vertices.

Referenced by computeTargetPosition(), computeTargetPosition(), momentum::PointTriangleVertexErrorFunctionT< T >::getError(), and momentum::SkinnedLocatorTriangleErrorFunctionT< T >::getError().

◆ computeTargetBaryPosition() [2/2]

template<typename T >

Eigen::Vector3< T > momentum::computeTargetBaryPosition	(	const MeshT< T > &	mesh,
		const SkinnedLocatorTriangleConstraintT< T > &	c
	)

Definition at line 67 of file skinned_locator_triangle_error_function.cpp.

References momentum::MeshT< T >::vertices.

◆ computeTargetPosition() [1/2]

template<typename T >

Eigen::Vector3< T > momentum::computeTargetPosition	(	const MeshT< T > &	mesh,
		const PointTriangleVertexConstraintT< T > &	c
	)

Definition at line 89 of file point_triangle_vertex_error_function.cpp.

References computeTargetBaryPosition(), and computeTargetTriangleNormal().

Referenced by momentum::PointTriangleVertexErrorFunctionT< T >::getError(), and momentum::SkinnedLocatorTriangleErrorFunctionT< T >::getError().

◆ computeTargetPosition() [2/2]

template<typename T >

Eigen::Vector3< T > momentum::computeTargetPosition	(	const MeshT< T > &	mesh,
		const SkinnedLocatorTriangleConstraintT< T > &	c
	)

Definition at line 85 of file skinned_locator_triangle_error_function.cpp.

References computeTargetBaryPosition(), and computeTargetTriangleNormal().

◆ computeTargetTriangleNormal() [1/2]

template<typename T >

Eigen::Vector3< T > momentum::computeTargetTriangleNormal	(	const MeshT< T > &	mesh,
		const PointTriangleVertexConstraintT< T > &	c
	)

Definition at line 80 of file point_triangle_vertex_error_function.cpp.

References momentum::MeshT< T >::vertices.

Referenced by computeTargetPosition(), computeTargetPosition(), momentum::PointTriangleVertexErrorFunctionT< T >::getError(), and momentum::SkinnedLocatorTriangleErrorFunctionT< T >::getError().

◆ computeTargetTriangleNormal() [2/2]

template<typename T >

Eigen::Vector3< T > momentum::computeTargetTriangleNormal	(	const MeshT< T > &	mesh,
		const SkinnedLocatorTriangleConstraintT< T > &	c
	)

Definition at line 76 of file skinned_locator_triangle_error_function.cpp.

References momentum::MeshT< T >::vertices.

◆ copyAccessorBuffer()

template<typename T >

std::vector< T > momentum::copyAccessorBuffer	(	const fx::gltf::Document &	model,
		int32_t	id
	)

Definition at line 55 of file accessor_utils.h.

References MT_LOGW.

◆ copyAlignedAccessorBuffer()

template<typename T >

std::vector< T > momentum::copyAlignedAccessorBuffer	(	const fx::gltf::Document &	model,
		int32_t	id
	)

Definition at line 89 of file accessor_utils.h.

References MT_LOGW.

◆ createAccessorBuffer()

template<typename T >

int32_t momentum::createAccessorBuffer	(	fx::gltf::Document &	model,
		std::span< T >	data,
		const bool	align = `false`,
		const bool	normalized = `false`
	)

Definition at line 134 of file accessor_utils.h.

Referenced by createSampler(), and createSampler().

◆ createConstraintData() [1/2]

std::vector< std::vector< PositionData > > momentum::createConstraintData	(	const std::span< const std::vector< Marker > >	markerData,
		const LocatorList &	locators
	)

Definition at line 29 of file tracker_utils.cpp.

Referenced by trackPosesForFrames(), and trackSequence().

◆ createConstraintData() [2/2]

std::vector< std::vector< momentum::PositionData > > momentum::createConstraintData	(	std::span< const std::vector< momentum::Marker > >	markerData,
		const momentum::LocatorList &	locators
	)

◆ createFloorConstraints()

template<typename T >

std::vector< PlaneDataT< T > > momentum::createFloorConstraints	(	const std::string &	prefix,
		const LocatorList &	locators,
		const Vector3< T > &	floorNormal,
		const T &	floorOffset,
		const float	weight
	)

Create non-penetration half-plane constraints from locators with the input prefix.

Definition at line 18 of file plane_error_function.cpp.

◆ createFloorConstraints< double >()

template std::vector< PlaneDataT< double > > momentum::createFloorConstraints< double >	(	const std::string &	prefix,
		const LocatorList &	locators,
		const Vector3d &	floorNormal,
		const double &	floorOffset,
		const float	weight
	)

◆ createFloorConstraints< float >()

template std::vector< PlaneDataT< float > > momentum::createFloorConstraints< float >	(	const std::string &	prefix,
		const LocatorList &	locators,
		const Vector3f &	floorNormal,
		const float &	floorOffset,
		const float	weight
	)

Referenced by trackPosesForFrames(), and trackSequence().

◆ createLocatorCharacter()

momentum::Character momentum::createLocatorCharacter	(	const Character &	sourceCharacter,
		const std::string &	prefix
	)

◆ createSampler() [1/2]

template<typename T >

int32_t momentum::createSampler	(	fx::gltf::Document &	model,
		fx::gltf::Animation &	anim,
		std::span< T >	data,
		const int32_t	timestampAccessor
	)

Definition at line 282 of file accessor_utils.h.

References createAccessorBuffer().

◆ createSampler() [2/2]

template<typename T >

int32_t momentum::createSampler	(	fx::gltf::Document &	model,
		fx::gltf::Animation &	anim,
		std::span< T >	data,
		const std::span< float > &	timestamps
	)

Definition at line 261 of file accessor_utils.h.

References createAccessorBuffer(), and MT_CHECK.

◆ createSkinnedConstraintData() [1/2]

std::vector< std::vector< SkinnedLocatorConstraint > > momentum::createSkinnedConstraintData	(	const std::span< const std::vector< Marker > >	markerData,
		const SkinnedLocatorList &	locators
	)

Definition at line 64 of file tracker_utils.cpp.

Referenced by trackPosesForFrames(), and trackSequence().

◆ createSkinnedConstraintData() [2/2]

std::vector< std::vector< momentum::SkinnedLocatorConstraint > > momentum::createSkinnedConstraintData	(	std::span< const std::vector< momentum::Marker > >	markerData,
		const momentum::SkinnedLocatorList &	locators
	)

◆ createSkinnedLocatorMeshConstraints()

std::vector< momentum::SkinnedLocatorTriangleConstraintT< float > > momentum::createSkinnedLocatorMeshConstraints	(	const momentum::Character &	character,
		float	targetDepth
	)

Definition at line 251 of file tracker_utils.cpp.

References closestPointOnMeshMatchingParent(), momentum::CharacterT< T >::mesh, momentum::CharacterT< T >::skinnedLocators, and momentum::CharacterT< T >::skinWeights.

Referenced by trackSequence().

◆ cross() [1/2]

template<typename S , typename Derived >

Vector3P< S > momentum::cross	(	const Eigen::MatrixBase< Derived > &	v1,
		const Vector3P< S > &	v2
	)

Calculates cross product of Eigen::Vector3f and Vector3P.

Template Parameters

Derived A derived class of Eigen::MatrixBase, which should be compatible with Eigen::Vector3f.

Parameters

[in]	v1	A 3D vector of Eigen.
[in]	v2	A 3-vector of packets.

Definition at line 198 of file simd.h.

Referenced by compute_d_targetNormal_d_vertexPos(), compute_d_targetNormal_d_vertexPos(), momentum::SimdNormalErrorFunction::getGradient(), intersectMesh(), intersectMeshBruteForce(), and momentum::MeshT< T >::updateNormals().

◆ cross() [2/2]

template<typename S , typename Derived >

Vector3P< S > momentum::cross	(	const Vector3P< S > &	v1,
		const Eigen::MatrixBase< Derived > &	v2
	)

Calculates cross product of Vector3P and Eigen::Vector3f.

Template Parameters

Derived A derived class of Eigen::MatrixBase, which should be compatible with Eigen::Vector3f.

Parameters

[in]	v1	A 3-vector of packets.
[in]	v2	A 3D vector of Eigen.

Definition at line 213 of file simd.h.

◆ crossProductMatrix()

template<typename T >

Eigen::Matrix< T, 3, 3 > momentum::crossProductMatrix ( const Eigen::Vector3< T > & v )

Creates a skew-symmetric matrix for computing cross products.

Returns a matrix M such that M*u = v×u for any vector u

Template Parameters

T	The scalar type

Parameters

v	Input vector

Returns: 3×3 skew-symmetric matrix

Definition at line 316 of file utility.h.

◆ d_modelParams_d_inputs()

template<typename T >

std::vector< ErrorFunctionDerivativesT< T > > momentum::d_modelParams_d_inputs	(	const Skeleton &	skeleton,
		const ParameterTransformT< T > &	parameterTransform,
		const ParameterSet &	activeParams,
		const ModelParametersT< T > &	modelParameters,
		SkeletonSolverFunctionT< T > &	solverFunction,
		Eigen::Ref< const Eigen::VectorX< T > >	dLoss_dModelParams,
		T *	gradientRmse
	)

Definition at line 112 of file fully_differentiable_body_ik.cpp.

References momentum::ParameterTransformT< T >::apply(), computeSubsetParameterIndices(), MT_LOGD, momentum::ParameterTransformT< T >::numAllModelParameters(), parameterTransform, skeleton, and momentum::MeshStateT< T >::update().

◆ d_modelParams_d_inputs< double >()

template std::vector< ErrorFunctionDerivativesT< double > > momentum::d_modelParams_d_inputs< double >	(	const Skeleton &	skeleton,
		const ParameterTransformT< double > &	parameterTransform,
		const ParameterSet &	activeParams,
		const ModelParametersT< double > &	modelParameters,
		SkeletonSolverFunctionT< double > &	solverFunction,
		Eigen::Ref< const Eigen::VectorX< double > >	dLoss_dModelParams,
		double *	gradientRmse
	)

◆ d_modelParams_d_inputs< float >()

template std::vector< ErrorFunctionDerivativesT< float > > momentum::d_modelParams_d_inputs< float >	(	const Skeleton &	skeleton,
		const ParameterTransformT< float > &	parameterTransform,
		const ParameterSet &	activeParams,
		const ModelParametersT< float > &	modelParameters,
		SkeletonSolverFunctionT< float > &	solverFunction,
		Eigen::Ref< const Eigen::VectorX< float > >	dLoss_dModelParams,
		float *	gradientRmse
	)

◆ dot() [1/2]

template<typename Derived , typename S >

FloatP momentum::dot	(	const Eigen::MatrixBase< Derived > &	v1,
		const Vector3P< S > &	v2
	)

Calculates dot product of Eigen::Vector3f and 3-vector of packets.

Template Parameters

Derived A derived class of Eigen::MatrixBase, which should be compatible with Eigen::Vector3f.

Parameters

[in]	v1	A 3D vector of Eigen.
[in]	v2	A 3-vector of packets.

Definition at line 93 of file simd.h.

Referenced by momentum::SkeletonStateT< T >::compare(), momentum::FixedAxisAngleErrorFunctionT< T >::evalFunction(), momentum::SimdPlaneErrorFunction::getError(), momentum::SimdPositionErrorFunction::getError(), momentum::SimdNormalErrorFunction::getError(), momentum::SimdNormalErrorFunction::getGradient(), and operator*().

◆ dot() [2/2]

template<typename Derived , typename S >

FloatP momentum::dot	(	const Vector3P< S > &	v1,
		const Eigen::MatrixBase< Derived > &	v2
	)

Calculates dot product of Vector3P and Eigen::Vector3f.

Template Parameters

Derived A derived class of Eigen::MatrixBase, which should be compatible with Eigen::Vector3f.

Parameters

[in]	v1	A 3-vector of packets.
[in]	v2	A 3D vector of Eigen.

Definition at line 104 of file simd.h.

◆ Eps()

template<typename T >

constexpr T momentum::Eps	(	T	FloatEps = `T(1e-7)`,
		T	DoubleEps = `T(1e-16)`
	)

constexpr

Returns the tolerance value based on the provided type T.

Definition at line 22 of file constants.h.

◆ eulerToQuaternion() [1/3]

template Quaternion< double > momentum::eulerToQuaternion	(	const Vector3< double > &	angles,
		int	axis0,
		int	axis1,
		int	axis2,
		EulerConvention	convention
	)

◆ eulerToQuaternion() [2/3]

template Quaternion< float > momentum::eulerToQuaternion	(	const Vector3< float > &	angles,
		int	axis0,
		int	axis1,
		int	axis2,
		EulerConvention	convention
	)

◆ eulerToQuaternion() [3/3]

template<typename T >

Quaternion< T > momentum::eulerToQuaternion	(	const Vector3< T > &	angles,
		int	axis0,
		int	axis1,
		int	axis2,
		EulerConvention	convention = `EulerConvention::Intrinsic`
	)

Converts Euler angles to quaternion.

Template Parameters

T	The scalar type.

Parameters

[in]	angles	The 3-dimensional vector of Euler angles in order.
[in]	axis0	The index of the first rotation's axis, one of {0, 1, 2}.
[in]	axis1	The index of the second rotation's axis, one of {0, 1, 2}.
[in]	axis2	The index of the third rotation's axis, one of {0, 1, 2}.
[in]	convention	The Euler angles convention.

Definition at line 291 of file utility.cpp.

References eulerToQuaternion(), Extrinsic, and Intrinsic.

Referenced by eulerToQuaternion().

◆ eulerToRotationMatrix() [1/3]

template Matrix3< double > momentum::eulerToRotationMatrix	(	const Vector3< double > &	angles,
		int	axis0,
		int	axis1,
		int	axis2,
		EulerConvention	convention
	)

◆ eulerToRotationMatrix() [2/3]

template Matrix3< float > momentum::eulerToRotationMatrix	(	const Vector3< float > &	angles,
		int	axis0,
		int	axis1,
		int	axis2,
		EulerConvention	convention
	)

◆ eulerToRotationMatrix() [3/3]

template<typename T >

Matrix3< T > momentum::eulerToRotationMatrix	(	const Vector3< T > &	angles,
		int	axis0,
		int	axis1,
		int	axis2,
		EulerConvention	convention = `EulerConvention::Intrinsic`
	)

Converts Euler angles to rotation matrix.

Template Parameters

T	The scalar type.

Parameters

[in]	angles	The 3-dimensional vector of Euler angles in order.
[in]	axis0	The index of the first rotation's axis, one of {0, 1, 2}.
[in]	axis1	The index of the second rotation's axis, one of {0, 1, 2}.
[in]	axis2	The index of the third rotation's axis, one of {0, 1, 2}.
[in]	convention	The Euler angles convention.

Definition at line 309 of file utility.cpp.

◆ eulerXYZToRotationMatrix() [1/3]

template Matrix3< double > momentum::eulerXYZToRotationMatrix	(	const Vector3< double > &	angles,
		EulerConvention	convention
	)

◆ eulerXYZToRotationMatrix() [2/3]

template Matrix3< float > momentum::eulerXYZToRotationMatrix	(	const Vector3< float > &	angles,
		EulerConvention	convention
	)

◆ eulerXYZToRotationMatrix() [3/3]

template<typename T >

Matrix3< T > momentum::eulerXYZToRotationMatrix	(	const Vector3< T > &	angles,
		EulerConvention	convention
	)

An optimized version of eulerToRotationMatrix(angles, 0, 1, 2, convention) or eulerToRotationMatrix(angles.reverse(), 2, 1, 0, convention).

Definition at line 319 of file utility.cpp.

References eulerZYXToRotationMatrix(), Extrinsic, and Intrinsic.

Referenced by eulerZYXToRotationMatrix().

◆ eulerZYXToRotationMatrix() [1/3]

template Matrix3< double > momentum::eulerZYXToRotationMatrix	(	const Vector3< double > &	angles,
		EulerConvention	convention
	)

◆ eulerZYXToRotationMatrix() [2/3]

template Matrix3< float > momentum::eulerZYXToRotationMatrix	(	const Vector3< float > &	angles,
		EulerConvention	convention
	)

◆ eulerZYXToRotationMatrix() [3/3]

template<typename T >

Matrix3< T > momentum::eulerZYXToRotationMatrix	(	const Vector3< T > &	angles,
		EulerConvention	convention
	)

An optimized version of eulerToRotationMatrix(angles, 2, 1, 0, convention) or eulerToRotationMatrix(angles.reverse(), 0, 1, 2, convention).

Definition at line 353 of file utility.cpp.

References eulerXYZToRotationMatrix(), Extrinsic, and Intrinsic.

Referenced by eulerXYZToRotationMatrix().

◆ extractBlendShapeFromParams()

Mesh momentum::extractBlendShapeFromParams	(	const momentum::ModelParameters &	param,
		const momentum::Character &	sourceCharacter
	)

Definition at line 495 of file tracker_utils.cpp.

References extractBlendWeights(), and momentum::MeshT< T >::vertices.

Referenced by calibrateModel().

◆ extractBlendWeights()

template<typename T >

BlendWeightsT< T > momentum::extractBlendWeights	(	const ParameterTransform &	paramTransform,
		const ModelParametersT< T > &	modelParams
	)

Extracts blend shape weights from model parameters.

Maps from the model parameter space to blend shape weights using the parameter transform. Use this function to get weights for identity/shape blend shapes (e.g., body shape variations).

Parameters

paramTransform	Mapping between model parameters and blend shape parameters
modelParams	Current model parameters

Returns: Vector of blend shape weights

Definition at line 22 of file blend_shape_skinning.cpp.

References momentum::EigenStrongType< Derived, EigenType >::size().

Referenced by momentum::CharacterT< T >::bake(), momentum::CharacterT< T >::bakeBlendShape(), extractBlendShapeFromParams(), skinWithBlendShapes(), and momentum::MeshStateT< T >::update().

◆ extractBlendWeights< double >()

template BlendWeightsT< double > momentum::extractBlendWeights< double >	(	const ParameterTransform &	paramTransform,
		const ModelParametersT< double > &	modelParams
	)

◆ extractBlendWeights< float >()

template BlendWeightsT< float > momentum::extractBlendWeights< float >	(	const ParameterTransform &	paramTransform,
		const ModelParametersT< float > &	modelParams
	)

◆ extractFaceExpressionBlendWeights()

template<typename T >

BlendWeightsT< T > momentum::extractFaceExpressionBlendWeights	(	const ParameterTransform &	paramTransform,
		const ModelParametersT< T > &	modelParams
	)

Extracts facial expression blend shape weights from model parameters.

Maps from the model parameter space to facial expression blend shape weights using the parameter transform. Use this function specifically for facial animation parameters, which are stored separately from regular blend shapes.

Parameters

paramTransform	Mapping between model parameters and face expression parameters
modelParams	Current model parameters

Returns: Vector of facial expression blend shape weights

Definition at line 36 of file blend_shape_skinning.cpp.

References momentum::EigenStrongType< Derived, EigenType >::size().

Referenced by momentum::MeshStateT< T >::update().

◆ extractFaceExpressionBlendWeights< double >()

template BlendWeightsT< double > momentum::extractFaceExpressionBlendWeights< double >	(	const ParameterTransform &	paramTransform,
		const ModelParametersT< double > &	modelParams
	)

◆ extractFaceExpressionBlendWeights< float >()

template BlendWeightsT< float > momentum::extractFaceExpressionBlendWeights< float >	(	const ParameterTransform &	paramTransform,
		const ModelParametersT< float > &	modelParams
	)

◆ extractIdAndLocatorsFromParams()

std::tuple< Eigen::VectorXf, momentum::LocatorList, momentum::SkinnedLocatorList > momentum::extractIdAndLocatorsFromParams	(	const ModelParameters &	param,
		const Character &	sourceCharacter,
		const Character &	targetCharacter
	)

Definition at line 477 of file tracker_utils.cpp.

References extractLocatorsFromCharacter(), extractParameters(), extractSkinnedLocatorsFromCharacter(), and momentum::CharacterParametersT< T >::pose.

Referenced by calibrateModel(), and refineMotion().

◆ extractLocatorsFromCharacter()

momentum::LocatorList momentum::extractLocatorsFromCharacter	(	const Character &	locatorCharacter,
		const CharacterParameters &	calibParams
	)

Definition at line 383 of file tracker_utils.cpp.

References momentum::SkeletonT< T >::joints, MT_LOGW, and skeleton.

Referenced by calibrateLocators(), and extractIdAndLocatorsFromParams().

◆ extractMarkersFromMotion()

std::vector< std::vector< momentum::Marker > > momentum::extractMarkersFromMotion	(	const Character &	character,
		const Eigen::MatrixXf &	motion
	)

Definition at line 561 of file tracker_utils.cpp.

References momentum::SkeletonStateT< T >::jointState, momentum::CharacterT< T >::locators, momentum::Marker::name, and momentum::CharacterT< T >::skeleton.

◆ extractParameters()

momentum::ModelParameters momentum::extractParameters	(	const ModelParameters &	params,
		const ParameterSet &	parameterSet
	)

Definition at line 466 of file tracker_utils.cpp.

Referenced by extractIdAndLocatorsFromParams(), and saveMotion().

◆ extractSkinnedLocatorsFromCharacter()

SkinnedLocatorList momentum::extractSkinnedLocatorsFromCharacter	(	const Character &	locatorCharacter,
		const CharacterParameters &	calibParams
	)

Definition at line 443 of file tracker_utils.cpp.

Referenced by extractIdAndLocatorsFromParams().

◆ extractSubsetMat()

template<typename T >

Eigen::MatrixX< T > momentum::extractSubsetMat	(	Eigen::Ref< const Eigen::MatrixX< T > >	fullMat,
		const std::vector< Eigen::Index > &	subsetIndexToFullParamIndex
	)

Definition at line 47 of file fully_differentiable_body_ik.cpp.

◆ extractSubsetVec()

template<typename T >

Eigen::VectorX< T > momentum::extractSubsetVec	(	Eigen::Ref< const Eigen::VectorX< T > >	fullVec,
		const std::vector< Eigen::Index > &	subsetIndexToFullParamIndex
	)

Definition at line 35 of file fully_differentiable_body_ik.cpp.

◆ extrapolateModelParameters() [1/2]

ModelParameters momentum::extrapolateModelParameters	(	const ModelParameters &	previous,
		const ModelParameters &	current,
		const ParameterSet &	activeParams,
		float	factor = `kDefaultExtrapolateFactor`,
		float	maxDelta = `kDefaultExtrapolateMaxDelta`
	)

Extrapolates model parameters considering active parameters.

The extrapolation is done by first clamping the difference between current and previous parameters to the range [-maxDelta, maxDelta] for each active parameter, and then scaling this clamped difference by factor. Returns the current parameters when sizes mismatch.

Definition at line 31 of file skeleton_utility.cpp.

References MT_PROFILE_FUNCTION.

◆ extrapolateModelParameters() [2/2]

ModelParameters momentum::extrapolateModelParameters	(	const ModelParameters &	previous,
		const ModelParameters &	current,
		float	factor = `kDefaultExtrapolateFactor`,
		float	maxDelta = `kDefaultExtrapolateMaxDelta`
	)

Extrapolates model parameters by first clamping the difference between current and previous parameters to the range [-maxDelta, maxDelta], and then scaling this clamped difference by factor.

Returns the current parameters when sizes mismatch.

Definition at line 13 of file skeleton_utility.cpp.

References MT_PROFILE_FUNCTION, and momentum::EigenStrongType< Derived, EigenType >::v.

◆ facesToVertices()

template<typename T >

std::vector< bool > momentum::facesToVertices	(	const MeshT< T > &	mesh,
		const std::vector< bool > &	activeFaces
	)

Converts face selection to vertex selection.

Parameters

[in]	character	Character containing the mesh
[in]	activeFaces	Boolean vector indicating which faces are active

Returns: Boolean vector indicating which vertices are used by active faces

Definition at line 1142 of file character_utility.cpp.

References momentum::MeshT< T >::faces, facesToVertices(), MT_CHECK, and momentum::MeshT< T >::vertices.

Referenced by facesToVertices(), and reduceMeshByFaces().

◆ facesToVertices< double >()

template std::vector< bool > momentum::facesToVertices< double >	(	const MeshT< double > &	mesh,
		const std::vector< bool > &	activeFaces
	)

◆ facesToVertices< float >()

template std::vector< bool > momentum::facesToVertices< float >	(	const MeshT< float > &	mesh,
		const std::vector< bool > &	activeFaces
	)

◆ fillIdentity()

void momentum::fillIdentity	(	const ParameterSet &	idSet,
		const ModelParameters &	identity,
		Eigen::MatrixXf &	motionNoId
	)

Definition at line 504 of file tracker_utils.cpp.

References MT_CHECK, and momentum::EigenStrongType< Derived, EigenType >::v.

◆ findMainSubjectIndex()

int momentum::findMainSubjectIndex ( std::span< const MarkerSequence > markerSequences )

Finds the "main subject" from a vector of MarkerSequences.

The main subject is currently defined as a named actor with the maximum number of visible markers in the sequence.

Parameters

[in] markerSequences A vector of MarkerSequences to search for the main subject.

Returns: int The main subject's index in the input vector. If no main subject found, -1 is returned.

Note: This function is exposed mainly for unit tests.

Definition at line 69 of file marker_io.cpp.

Referenced by loadMarkersForMainSubject(), and processMarkerFile().

◆ fromJson()

template<typename T >

T momentum::fromJson ( const nlohmann::json & j )

Definition at line 40 of file json_utils.h.

◆ fromMomentumQuaternionf()

std::array< float, 4 > momentum::fromMomentumQuaternionf ( const Quaternionf & quat )

inlinenoexcept

Definition at line 31 of file coordinate_utils.h.

Referenced by momentum::GltfBuilder::addCharacter().

◆ fromMomentumVec3f() [1/3]

Vector3f momentum::fromMomentumVec3f ( const Vector3f & vec )

inlinenoexcept

Definition at line 22 of file coordinate_utils.h.

References toM().

Referenced by momentum::GltfBuilder::addCharacter().

◆ fromMomentumVec3f() [2/3]

void momentum::fromMomentumVec3f ( std::vector< Vector3f > & vec )

inline

Definition at line 44 of file coordinate_utils.h.

References toM().

◆ fromMomentumVec3f() [3/3]

void momentum::fromMomentumVec3f ( VectorXf & vec )

inline

Definition at line 52 of file coordinate_utils.h.

References toM().

◆ getAuxiliaryDataFromMotion()

std::tuple< MatrixXf, std::vector< std::string > > momentum::getAuxiliaryDataFromMotion	(	const MatrixXf &	poses,
		std::span< const std::string >	parameterNames
	)

Extract auxiliary data from motion parameters.

Auxiliary parameters are identified by names wrapped with double underscores (e.g., "__param__")

Parameters

poses	Motion poses matrix
parameterNames	Names of all parameters

Returns: Tuple of (auxiliary data matrix, auxiliary parameter names without underscores)

Definition at line 224 of file mmo_io.cpp.

◆ getDimensions()

template<typename T >

std::pair< size_t, std::vector< size_t > > momentum::getDimensions ( const std::vector< std::shared_ptr< SkeletonErrorFunctionT< T > > > & error_func )

Definition at line 114 of file skeleton_solver_function.cpp.

References MT_PROFILE_FUNCTION.

Referenced by momentum::SkeletonSolverFunctionT< T >::getJacobian(), and momentum::SkeletonSolverFunctionT< T >::getJtJR().

◆ getInverseSSDTransformation()

Affine3f momentum::getInverseSSDTransformation	(	const TransformationList &	inverseBindPose,
		const SkinWeights &	skin,
		const SkeletonState &	state,
		size_t	index
	)

Computes the inverse SSD transformation for a specific vertex.

Returns a transformation matrix that converts from skinned space back to bind pose space. This is useful for operations that need to work in the original bind pose space.

Parameters

inverseBindPose	Inverse bind pose transformations for each joint
skin	Skin weights defining influence of each joint on vertices
state	Current skeleton state containing joint transformations
index	Index of the vertex to compute inverse transformation for

Returns: Inverse transformation matrix for the specified vertex

Definition at line 201 of file linear_skinning.cpp.

References getInverseSSDTransformation(), and MT_CHECK.

Referenced by getInverseSSDTransformation().

◆ GetLineCrossPlatform()

std::istream & momentum::GetLineCrossPlatform	(	std::istream &	is,
		std::string &	line
	)

Reads a line from the input stream, handling line endings for different platforms.

This function reads a line from the given input stream and stores it in the 'line' parameter. It properly handles line endings for different platforms (e.g., LF for Unix, CRLF for Windows).

Parameters

[in,out]	is	Reference to the input stream from which the line should be read.
[in,out]	line	Reference to the string variable where the line will be stored.

Returns: Reference to the input stream after reading the line.

Definition at line 39 of file stream_utils.cpp.

Referenced by loadTrc().

◆ getLocatorError() [1/2]

std::pair< float, float > momentum::getLocatorError	(	std::span< const std::vector< momentum::Marker > >	markerData,
		const Eigen::MatrixXf &	motion,
		momentum::Character &	character
	)

Get the error of the locator motion vs the markers.

Parameters

[in]	markerData	Input marker data.
[in]	motion	Motion to compare against.
[in]	character	Character definition

Returns: average per frame error and max marker error

◆ getLocatorError() [2/2]

std::pair< float, float > momentum::getLocatorError	(	std::span< const std::vector< momentum::Marker > >	markerData,
		const MatrixXf &	motion,
		momentum::Character &	character
	)

Compute average and maximum marker tracking errors across all frames.

This is a utility function for evaluating tracking quality by measuring the Euclidean distance between observed marker positions and their corresponding locator positions on the character. It provides both average error per frame and the maximum error encountered across all markers and frames.

Parameters

markerData	Marker observations for each frame
motion	Solved motion parameters matrix (parameters x frames)
character	Character model with locators

Returns: Pair of (average_error, max_error) in world units

Definition at line 1135 of file marker_tracker.cpp.

References momentum::CharacterT< T >::locators, MT_CHECK, MT_LOGI, momentum::ParameterTransformT< T >::numAllModelParameters(), momentum::CharacterT< T >::parameterTransform, momentum::SkeletonStateT< T >::set(), and momentum::CharacterT< T >::skeleton.

Referenced by processMarkers().

◆ getLogLevel()

LogLevel momentum::getLogLevel ( )

Definition at line 93 of file log.cpp.

References Debug, Disabled, Error, Info, MT_LOGW, Trace, and Warning.

◆ getPoseConstraintParameterLimits()

ParameterLimits momentum::getPoseConstraintParameterLimits	(	const std::string &	name,
		const ParameterTransform &	pt,
		const float	weight
	)

Creates MinMax limits from a pose constraint.

Definition at line 65 of file parameter_limits.cpp.

References momentum::ParameterLimit::data, momentum::LimitMinMax::limits, MinMax, momentum::LimitData::minMax, momentum::LimitMinMax::parameterIndex, momentum::ParameterLimit::type, and momentum::ParameterLimit::weight.

Referenced by trackSequence().

◆ getRotationDerivative()

template<typename T , typename T2 >

Eigen::Vector3< T > momentum::getRotationDerivative	(	const JointStateT< T2 > &	js,
		const size_t	index,
		const Eigen::Vector3< T > &	ref
	)

Definition at line 20 of file ceres_utility.h.

Referenced by momentum::FullyDifferentiableProjectionErrorFunctionT< T >::constraintGradient_dot().

◆ getScaleDerivative()

template<typename T , typename T2 >

Eigen::Vector3< T > momentum::getScaleDerivative	(	const JointStateT< T2 > &	js,
		const Eigen::Vector3< T > &	ref
	)

Definition at line 25 of file ceres_utility.h.

Referenced by momentum::FullyDifferentiableProjectionErrorFunctionT< T >::constraintGradient_dot().

◆ gradient_jointParams_to_modelParams() [1/2]

template<typename T >

void momentum::gradient_jointParams_to_modelParams	(	const T &	grad_jointParams,
		const Eigen::Index	iJointParam,
		const ParameterTransform &	parameterTransform,
		Eigen::Ref< Eigen::VectorX< T > >	gradient
	)

Definition at line 16 of file error_function_utils.h.

References parameterTransform, and momentum::ParameterTransformT< T >::transform.

Referenced by momentum::StateErrorFunctionT< T >::getGradient().

◆ gradient_jointParams_to_modelParams() [2/2]

template<typename T >

void momentum::gradient_jointParams_to_modelParams	(	const T	grad_jointParams,
		const Eigen::Index	iJointParam,
		const ParameterTransform &	parameterTransform,
		Eigen::Ref< Eigen::VectorX< T > >	gradient
	)

Definition at line 147 of file point_triangle_vertex_error_function.cpp.

References parameterTransform, and momentum::ParameterTransformT< T >::transform.

◆ hessianInverseTimes()

template<typename T >

Eigen::VectorX< T > momentum::hessianInverseTimes	(	Eigen::Ref< const Eigen::MatrixX< T > >	jacobian,
		Eigen::Ref< const Eigen::VectorX< T > >	v
	)

Definition at line 75 of file fully_differentiable_body_ik.cpp.

References sqr().

◆ intersectFace()

template<typename T >

bool momentum::intersectFace	(	const MeshT< T > &	mesh,
		const std::vector< Vector3< T > > &	faceNormals,
		const int32_t	face0,
		const int32_t	face1
	)

test whether two given faces of a mesh intersect with each other

Definition at line 27 of file intersection.cpp.

References momentum::MeshT< T >::faces, and momentum::MeshT< T >::vertices.

Referenced by intersectMesh(), and intersectMeshBruteForce().

◆ intersectFace< double >()

template bool momentum::intersectFace< double >	(	const MeshT< double > &	mesh,
		const std::vector< Vector3< double > > &	faceNormals,
		const int32_t	face0,
		const int32_t	face1
	)

◆ intersectFace< float >()

template bool momentum::intersectFace< float >	(	const MeshT< float > &	mesh,
		const std::vector< Vector3< float > > &	faceNormals,
		const int32_t	face0,
		const int32_t	face1
	)

◆ intersectMesh()

template<typename T >

std::vector< std::pair< int32_t, int32_t > > momentum::intersectMesh ( const MeshT< T > & mesh )

test if the mesh self intersects anywhere and return all intersecting face pairs using a bvh tree

Definition at line 119 of file intersection.cpp.

References cross(), momentum::MeshT< T >::faces, intersectFace(), and momentum::MeshT< T >::vertices.

◆ intersectMesh< double >()

template std::vector< std::pair< int32_t, int32_t > > momentum::intersectMesh< double > ( const MeshT< double > & mesh )

◆ intersectMesh< float >()

template std::vector< std::pair< int32_t, int32_t > > momentum::intersectMesh< float > ( const MeshT< float > & mesh )

◆ intersectMeshBruteForce()

template<typename T >

std::vector< std::pair< int32_t, int32_t > > momentum::intersectMeshBruteForce ( const MeshT< T > & mesh )

test if the mesh self intersects anywhere and return all intersecting face pairs using brute force

Definition at line 94 of file intersection.cpp.

References cross(), momentum::MeshT< T >::faces, intersectFace(), and momentum::MeshT< T >::vertices.

◆ intersectMeshBruteForce< double >()

template std::vector< std::pair< int32_t, int32_t > > momentum::intersectMeshBruteForce< double > ( const MeshT< double > & mesh )

◆ intersectMeshBruteForce< float >()

template std::vector< std::pair< int32_t, int32_t > > momentum::intersectMeshBruteForce< float > ( const MeshT< float > & mesh )

◆ isApprox()

template<typename T = float>

bool momentum::isApprox	(	T	l,
		T	r,
		T	eps = `Eps<T>(1e-4, 1e-6)`
	)

noexcept

Determines if two values are approximately equal within a given tolerance.

Definition at line 53 of file utility.h.

Referenced by momentum::MppcaT< T >::isApprox(), momentum::TaperedCapsuleT< S >::isApprox(), momentum::Locator::operator==(), momentum::ParameterLimit::operator==(), momentum::PoseConstraint::operator==(), and momentum::SkinnedLocator::operator==().

◆ isGlobalTransformZero()

bool momentum::isGlobalTransformZero	(	const Eigen::VectorXf &	dof,
		const ParameterSet &	rigidParams
	)

Check if the global transform is zero by checking if any rigid parameters are non-zero.

This is used to determine whether initialization is needed for pose tracking. If all rigid parameters are zero, we need to solve for an initial rigid transform.

Parameters

dof	The parameter vector to check
rigidParams	Parameter set defining which parameters are rigid/global

Returns: True if global transform is zero (needs initialization), false otherwise

Definition at line 452 of file marker_tracker.cpp.

Referenced by trackPosesForFrames().

◆ isInRange() [1/2]

bool momentum::isInRange	(	const LimitLinear &	limit,
		float	value
	)

If rangeMin and rangeMax are both 0, the limit applies to all values.

Definition at line 104 of file parameter_limits.cpp.

Referenced by momentum::LimitErrorFunctionT< T >::getError(), momentum::LimitErrorFunctionT< T >::getGradient(), and momentum::LimitErrorFunctionT< T >::getJacobian().

◆ isInRange() [2/2]

bool momentum::isInRange	(	const LimitLinearJoint &	limit,
		float	value
	)

If rangeMin and rangeMax are both 0, the limit applies to all values.

Definition at line 114 of file parameter_limits.cpp.

◆ IsNanNoOpt()

bool momentum::IsNanNoOpt ( float f )

inline

NaN check function that isn't optimized away by fastmath.

Unlike std::isnan(), this implementation is not affected by compiler optimizations when using fast math options

Definition at line 25 of file utility.h.

Referenced by momentum::MeshT< T >::updateNormals().

◆ jacobian_jointParams_to_modelParams() [1/5]

template<typename T >

void momentum::jacobian_jointParams_to_modelParams	(	const Eigen::Ref< const Eigen::VectorX< T > > &	jacobian_jointParams,
		const Eigen::Index	iJointParam,
		const ParameterTransform &	parameterTransform,
		Eigen::Ref< Eigen::MatrixX< T > >	jacobian
	)

Definition at line 31 of file error_function_utils.h.

References parameterTransform, and momentum::ParameterTransformT< T >::transform.

◆ jacobian_jointParams_to_modelParams() [2/5]

template<typename T >

void momentum::jacobian_jointParams_to_modelParams	(	const Eigen::Ref< const Eigen::VectorX< T > >	jacobian_jointParams,
		const Eigen::Index	iJointParam,
		const ParameterTransform &	parameterTransform,
		Eigen::Ref< Eigen::MatrixX< T > >	jacobian
	)

Definition at line 162 of file point_triangle_vertex_error_function.cpp.

References parameterTransform, and momentum::ParameterTransformT< T >::transform.

◆ jacobian_jointParams_to_modelParams() [3/5]

__vectorcall DRJIT_INLINE void momentum::jacobian_jointParams_to_modelParams	(	const FloatP &	jacobian_jointParams,
		const Eigen::Index	iJointParam,
		const ParameterTransform &	parameterTransform_,
		Eigen::Ref< Eigen::MatrixX< float > >	jacobian
	)

Definition at line 270 of file simd_normal_error_function.cpp.

References momentum::ParameterTransformT< T >::transform.

◆ jacobian_jointParams_to_modelParams() [4/5]

template<typename T >

void momentum::jacobian_jointParams_to_modelParams	(	const T &	jacobian_jointParams,
		const Eigen::Index	iJointParam,
		const ParameterTransform &	parameterTransform,
		Eigen::Ref< Eigen::MatrixX< T > >	jacobian
	)

Definition at line 46 of file error_function_utils.h.

References parameterTransform, and momentum::ParameterTransformT< T >::transform.

◆ jacobian_jointParams_to_modelParams() [5/5]

template<typename T >

void momentum::jacobian_jointParams_to_modelParams	(	const T	jacobian_jointParams,
		const Eigen::Index	iJointParam,
		const ParameterTransform &	parameterTransform,
		Eigen::Ref< Eigen::MatrixX< T > >	jacobian
	)

Definition at line 177 of file point_triangle_vertex_error_function.cpp.

References parameterTransform, and momentum::ParameterTransformT< T >::transform.

◆ jointIdentityToModelIdentity()

ModelParameters momentum::jointIdentityToModelIdentity	(	const Character &	c,
		const ParameterSet &	idSet,
		const JointParameters &	jointIdentity
	)

Definition at line 540 of file tracker_utils.cpp.

References momentum::EigenStrongType< Derived, EigenType >::Zero().

Referenced by loadCalibratedModel(), and loadCharacterWithIdentity().

◆ ln2()

template<typename T = float>

constexpr T momentum::ln2 ( )

constexprnoexcept

< log_e 2

Definition at line 31 of file constants.h.

Referenced by momentum::SimdNormalErrorFunction::getGradient().

◆ loadBlendShape() [1/2]

BlendShape momentum::loadBlendShape	(	const filesystem::path &	filename,
		int	expectedShapes = `-1`,
		int	expectedVertices = `-1`
	)

Loads a blend shape from a file, including base shape and shape vectors.

Parameters

filename	Path to the blend shape data file
expectedShapes	Limits number of shape vectors loaded if > 0, otherwise loads all
expectedVertices	Limits number of vertices loaded if > 0, otherwise loads all

Returns: BlendShape object with loaded data

Note: Only supports local files. For non-local paths, use the stream version.

Definition at line 89 of file blend_shape_io.cpp.

References loadBlendShape().

Referenced by loadBlendShape().

◆ loadBlendShape() [2/2]

BlendShape momentum::loadBlendShape	(	std::istream &	data,
		int	expectedShapes = `-1`,
		int	expectedVertices = `-1`
	)

Loads a blend shape from a stream, including base shape and shape vectors.

Parameters

data	Input stream containing blend shape data
expectedShapes	Limits number of shape vectors loaded if > 0, otherwise loads all
expectedVertices	Limits number of vertices loaded if > 0, otherwise loads all

Returns: BlendShape object with loaded data

Definition at line 94 of file blend_shape_io.cpp.

◆ loadBlendShapeBase() [1/2]

BlendShapeBase momentum::loadBlendShapeBase	(	const filesystem::path &	filename,
		int	expectedShapes = `-1`,
		int	expectedVertices = `-1`
	)

Loads blend shape vectors from a file without base shape.

Parameters

filename	Path to the blend shape base data file
expectedShapes	Limits number of shape vectors loaded if > 0, otherwise loads all
expectedVertices	Limits number of vertices loaded if > 0, otherwise loads all

Returns: BlendShapeBase object with loaded shape vectors

Definition at line 66 of file blend_shape_io.cpp.

References loadBlendShapeBase().

Referenced by loadBlendShapeBase().

◆ loadBlendShapeBase() [2/2]

BlendShapeBase momentum::loadBlendShapeBase	(	std::istream &	data,
		int	expectedShapes = `-1`,
		int	expectedVertices = `-1`
	)

Loads blend shape vectors from a stream without base shape.

Parameters

data	Input stream containing blend shape base data
expectedShapes	Limits number of shape vectors loaded if > 0, otherwise loads all
expectedVertices	Limits number of vertices loaded if > 0, otherwise loads all

Returns: BlendShapeBase object with loaded shape vectors

Definition at line 71 of file blend_shape_io.cpp.

◆ loadC3d()

std::vector< MarkerSequence > momentum::loadC3d	(	const std::string &	filename,
		UpVector	up = `UpVector::Y`,
		std::span< const std::string >	validMarkerNames = `{}`
	)

Loads all the subjects from a C3D file into a vector of MarkerSequences.

The function reads the given C3D file and stores the marker data as a MarkerSequence. The unit of the input file will be read from the file and converted to the momentum unit (i.e., cm). The UpVector parameter 'up' is the up-vector convention of the input marker file.

Parameters

[in]	filename	The C3D file to load marker data from.
[in]	up	(Optional) The up-vector convention of the input marker file (default: UpVector::Y).

Returns: std::vector<MarkerSequence> A vector containing the marker sequences from the C3D file.

Definition at line 73 of file c3d_io.cpp.

References MT_LOGD, MT_LOGE, MT_LOGW_IF, momentum::Marker::name, and toMomentumVector3().

Referenced by loadMarkers().

◆ loadCalibratedModel()

std::tuple< momentum::Character, momentum::ModelParameters > momentum::loadCalibratedModel ( const std::string & modelFile )

Definition at line 149 of file app_utils.cpp.

References jointIdentityToModelIdentity(), and loadCharacterWithMotion().

◆ loadCharacterFromLegacyJson()

Character momentum::loadCharacterFromLegacyJson ( const std::string & jsonPath )

Loads a Character from a legacy JSON format that was previously used by older Python libraries (and some other tools).

The legacy JSON format contains:

"skeleton": FBX skeleton structure with joints, hierarchy, and transforms
"skinnedmodel": Mesh data with skinning weights
"collision": Optional collision geometry (tapered capsules)

Parameters

[in] jsonPath Path to the legacy JSON file

Returns: The loaded Character object

Exceptions

std::runtime_error if the file cannot be loaded or parsed

Definition at line 500 of file legacy_json_io.cpp.

References loadCharacterFromLegacyJsonString(), and MT_THROW_IF.

◆ loadCharacterFromLegacyJsonBuffer()

Character momentum::loadCharacterFromLegacyJsonBuffer ( std::span< const std::byte > jsonBuffer )

Loads a Character from a legacy JSON buffer.

Parameters

[in] jsonBuffer Buffer containing the legacy JSON data

Returns: The loaded Character object

Exceptions

std::runtime_error if the buffer cannot be parsed

Definition at line 510 of file legacy_json_io.cpp.

References loadCharacterFromLegacyJsonString().

◆ loadCharacterFromLegacyJsonString()

Character momentum::loadCharacterFromLegacyJsonString ( const std::string & jsonString )

Loads a Character from a legacy JSON string.

Parameters

[in] jsonString String containing the legacy JSON data

Returns: The loaded Character object

Exceptions

std::runtime_error if the string cannot be parsed

Definition at line 515 of file legacy_json_io.cpp.

References momentum::ParameterTransformT< float >::empty(), momentum::SkeletonT< T >::joints, kParametersPerJoint, MT_THROW_IF, parameterTransform, and skeleton.

Referenced by loadCharacterFromLegacyJson(), and loadCharacterFromLegacyJsonBuffer().

◆ loadCharacterWithIdentity()

std::tuple< momentum::Character, momentum::ModelParameters > momentum::loadCharacterWithIdentity ( const ModelOptions & modelFiles )

Definition at line 160 of file app_utils.cpp.

References jointIdentityToModelIdentity(), loadCharacterWithMotion(), loadFullCharacter(), loadLocators(), momentum::CharacterT< T >::locators, momentum::ParameterTransformT< T >::numAllModelParameters(), momentum::CharacterT< T >::parameterTransform, momentum::CharacterT< T >::skeleton, and momentum::EigenStrongType< Derived, EigenType >::Zero().

Referenced by processMarkerFile().

◆ loadCharacterWithMotion() [1/2]

std::tuple< Character, MatrixXf, VectorXf, float > momentum::loadCharacterWithMotion ( const filesystem::path & gltfFilename )

Load a glTF character from a local file path.

This function assumes the file format of the given path is glTF without checking the extension, so please ensure the file is in glTF format.

Parameters

[in] filepath The path to the glTF character file.

Returns: A tuple containing the loaded Character object, the motion represented in model parameters, the identity vector represented as joint parameters, and the fps.

Definition at line 1190 of file gltf_io.cpp.

Referenced by loadCalibratedModel(), and loadCharacterWithIdentity().

◆ loadCharacterWithMotion() [2/2]

std::tuple< Character, MatrixXf, VectorXf, float > momentum::loadCharacterWithMotion ( std::span< const std::byte > byteSpan )

Load a glTF character from a buffer.

Parameters

[in] byteSpan The buffer containing the glTF character data.

Returns: A tuple containing the loaded Character object, the motion represented in model parameters, the identity vector represented as joint parameters, and the fps.

Definition at line 1195 of file gltf_io.cpp.

◆ loadCharacterWithSkeletonStates() [1/2]

std::tuple< Character, std::vector< SkeletonState >, std::vector< float > > momentum::loadCharacterWithSkeletonStates ( const filesystem::path & gltfFilename )

Definition at line 1206 of file gltf_io.cpp.

◆ loadCharacterWithSkeletonStates() [2/2]

std::tuple< Character, std::vector< SkeletonState >, std::vector< float > > momentum::loadCharacterWithSkeletonStates ( std::span< const std::byte > byteSpan )

Load a GLTF Character with motion in the form of skeleton states (transform matrices)

Unlike the other loadCharacterWithMotion functions, this function does not require the file to be saved using momentum's functionality that saves model parameters in a custom GTLF extension, however the resulting skeleton states may be harder to work with.

Definition at line 1201 of file gltf_io.cpp.

◆ loadFbxCharacter() [1/2]

Character momentum::loadFbxCharacter	(	const filesystem::path &	inputPath,
		KeepLocators	keepLocators,
		bool	permissive,
		LoadBlendShapes	loadBlendShapes,
		bool	stripNamespaces
	)

Definition at line 749 of file fbx_io.cpp.

References loadOpenFbxCharacter().

◆ loadFbxCharacter() [2/2]

Character momentum::loadFbxCharacter	(	std::span< const std::byte >	inputSpan,
		KeepLocators	keepLocators,
		bool	permissive,
		LoadBlendShapes	loadBlendShapes,
		bool	stripNamespaces
	)

Definition at line 759 of file fbx_io.cpp.

References loadOpenFbxCharacter().

◆ loadFbxCharacterWithMotion() [1/2]

std::tuple< Character, std::vector< MatrixXf >, float > momentum::loadFbxCharacterWithMotion	(	const filesystem::path &	inputPath,
		KeepLocators	keepLocators,
		bool	permissive,
		LoadBlendShapes	loadBlendShapes,
		bool	stripNamespaces
	)

Definition at line 769 of file fbx_io.cpp.

References loadOpenFbxCharacterWithMotion().

◆ loadFbxCharacterWithMotion() [2/2]

std::tuple< Character, std::vector< MatrixXf >, float > momentum::loadFbxCharacterWithMotion	(	std::span< const std::byte >	inputSpan,
		KeepLocators	keepLocators,
		bool	permissive,
		LoadBlendShapes	loadBlendShapes,
		bool	stripNamespaces
	)

Definition at line 779 of file fbx_io.cpp.

References loadOpenFbxCharacterWithMotion().

◆ loadFbxMarkerSequence()

MarkerSequence momentum::loadFbxMarkerSequence	(	const filesystem::path &	filename,
		bool	stripNamespaces = `true`
	)

Loads a MarkerSequence from an FBX file.

This function reads motion capture marker data from an FBX file and returns it as a MarkerSequence. The markers must be stored in the FBX scene hierarchy under a "Markers" root node, and each marker node must have the custom property "Momentum_Marker" to be recognized. The Markers root node must have the custom property "Momentum_Markers_Root" to be identified.

Parameters

[in]	filename	Path to the FBX file containing marker data.
	stripNamespaces	Removes namespace from joints when true. True by default

Returns: A MarkerSequence object containing the marker animation data, including marker positions per frame and fps. Returns an empty sequence if no markers or animations are found.

Definition at line 789 of file fbx_io.cpp.

References loadOpenFbxMarkerSequence().

Referenced by loadMarkers().

◆ loadFullCharacter()

Character momentum::loadFullCharacter	(	const std::string &	characterPath,
		const std::string &	parametersPath = `std::string()`,
		const std::string &	locatorsPath = `std::string()`
	)

High level function to load a character of any type, with a local path.

Parameters

[in]	characterPath	The path to the character file.
[in]	parametersPath	The optional path to the file containing additional parameters for the character.
[in]	locatorsPath	The optional path to the file containing additional locators for the character.

Returns: The loaded Character object.

Currently, only supports .glb and .fbx. If you want to parse from a non-local path, you may need to parse it using your favorite resource retriever into a buffer and use the buffer version of this function.

Definition at line 91 of file character_io.cpp.

References loadLocators(), loadMomentumModel(), loadParameters(), MT_THROW_IF, and Unknown.

Referenced by loadCharacterWithIdentity().

◆ loadFullCharacterFromBuffer()

Character momentum::loadFullCharacterFromBuffer	(	CharacterFormat	format,
		std::span< const std::byte >	characterBuffer,
		std::span< const std::byte >	paramBuffer = `std::span< const std::byte >()`,
		std::span< const std::byte >	locBuffer = `std::span< const std::byte >()`
	)

Buffer version of loadFullCharacter function, supports .glb and .fbx file formats.

Parameters

[in]	format	The character file format.
[in]	characterBuffer	The buffer containing the character data.
[in]	paramBuffer	The optional buffer containing additional parameters for the character.
[in]	locBuffer	The optional buffer containing additional locators for the character.

Returns: The loaded Character object.

Definition at line 119 of file character_io.cpp.

References loadLocatorsFromBuffer(), loadMomentumModelFromBuffer(), loadParameters(), and MT_THROW_IF.

◆ loadGltfCharacter() [1/3]

Character momentum::loadGltfCharacter ( const filesystem::path & gltfFilename )

Definition at line 1167 of file gltf_io.cpp.

◆ loadGltfCharacter() [2/3]

Character momentum::loadGltfCharacter ( const fx::gltf::Document & model )

Definition at line 1162 of file gltf_io.cpp.

◆ loadGltfCharacter() [3/3]

Character momentum::loadGltfCharacter ( std::span< const std::byte > byteSpan )

Definition at line 1171 of file gltf_io.cpp.

◆ loadLocators()

LocatorList momentum::loadLocators	(	const filesystem::path &	filename,
		const Skeleton &	skeleton,
		const ParameterTransform &	parameterTransform
	)

Definition at line 88 of file locator_io.cpp.

References loadLocatorsFromBuffer(), MT_THROW_IF, parameterTransform, and skeleton.

Referenced by loadCharacterWithIdentity(), and loadFullCharacter().

◆ loadLocatorsFromBuffer()

LocatorList momentum::loadLocatorsFromBuffer	(	std::span< const std::byte >	rawData,
		const Skeleton &	skeleton,
		const ParameterTransform &	parameterTransform
	)

Definition at line 107 of file locator_io.cpp.

References momentum::ParameterTransformT< T >::bindPose(), momentum::SkeletonT< T >::joints, kInvalidIndex, MT_LOGW, MT_THROW_IF, parameterTransform, skeleton, tokenize(), and trim().

Referenced by loadFullCharacterFromBuffer(), and loadLocators().

◆ loadMarkers()

std::vector< MarkerSequence > momentum::loadMarkers	(	const std::string &	filename,
		UpVector	up = `UpVector::Y`,
		std::span< const std::string >	validMarkerNames = `{}`
	)

Loads all actor sequences from a marker file (c3d, trc, glb) and converts the positions to the target coordinate system.

Default target coordinate system is: (Y-up, right-handed, centimeter units).

Parameters

[in]	filename	The marker file to load data from.
[in]	up	(Optional) The up-vector convention of the input marker file (default: UpVector::Y).

Returns: std::vector<MarkerSequence> A vector of MarkerSequences containing the marker data from the file.

Definition at line 32 of file marker_io.cpp.

References loadC3d(), loadFbxMarkerSequence(), loadMarkerSequence(), loadTrc(), and MT_LOGE.

Referenced by loadMarkersForMainSubject(), and processMarkerFile().

◆ loadMarkerSequence()

MarkerSequence momentum::loadMarkerSequence ( const filesystem::path & filename )

Loads a MarkerSequence from a file.

Parameters

[in] filename Path to the file containing the MarkerSequence data.

Returns: A MarkerSequence object containing motion capture marker data.

Definition at line 1250 of file gltf_io.cpp.

References momentum::MarkerSequence::fps, momentum::MarkerSequence::frames, MT_CHECK, and toMomentumVec3f().

Referenced by loadMarkers().

◆ loadMarkersForMainSubject()

std::optional< MarkerSequence > momentum::loadMarkersForMainSubject	(	const std::string &	filename,
		UpVector	up = `UpVector::Y`,
		std::span< const std::string >	validMarkerNames = `{}`
	)

Loads the main subject's marker data from a marker file (c3d, trc, glb) and converts the positions to the target coordinate system.

Default target coordinate system is: (Y-up, right-handed, centimeter units). The main subject is determined as the one with the most number of visible markers in the first frame.

Parameters

[in]	filename	The marker file to load data from.
[in]	up	(Optional) The up-vector convention of the input marker file (default: UpVector::Y).

Returns: std::optional<MarkerSequence> A MarkerSequence containing the main subject's marker data, or an empty optional if no main subject is found.

Definition at line 56 of file marker_io.cpp.

References findMainSubjectIndex(), and loadMarkers().

◆ loadMmo() [1/2]

std::tuple< MatrixXf, VectorXf, std::vector< std::string >, std::vector< std::string > > momentum::loadMmo ( const std::string & filename )

Load motion data from file.

Parameters

filename Input file path

Returns: Tuple of (poses, scale, parameter names, joint names)

Definition at line 249 of file mmo_io.cpp.

References kParametersPerJoint, and MT_LOGW.

◆ loadMmo() [2/2]

std::tuple< MatrixXf, VectorXf > momentum::loadMmo	(	const std::string &	filename,
		const Character &	character
	)

Load motion data and map to character parameter space.

Parameters

filename	Input file path
character	Target character for parameter mapping

Returns: Tuple of (mapped poses, mapped scale)

Definition at line 218 of file mmo_io.cpp.

References loadMmo(), and mapMotionToCharacter().

Referenced by loadMmo().

◆ loadModelDefinition() [1/2]

std::tuple< ParameterTransform, ParameterLimits > momentum::loadModelDefinition	(	const filesystem::path &	filename,
		const Skeleton &	skeleton
	)

Definition at line 534 of file parameter_transform_io.cpp.

References MT_THROW_IF, and skeleton.

◆ loadModelDefinition() [2/2]

std::tuple< ParameterTransform, ParameterLimits > momentum::loadModelDefinition	(	std::span< const std::byte >	rawData,
		const Skeleton &	skeleton
	)

Definition at line 546 of file parameter_transform_io.cpp.

References MT_THROW_IF, and skeleton.

◆ loadMomentumModel()

std::unordered_map< std::string, std::string > momentum::loadMomentumModel ( const filesystem::path & filename )

Definition at line 258 of file parameter_transform_io.cpp.

References MT_THROW_IF.

Referenced by loadFullCharacter().

◆ loadMomentumModelFromBuffer()

std::unordered_map< std::string, std::string > momentum::loadMomentumModelFromBuffer ( std::span< const std::byte > buffer )

Definition at line 274 of file parameter_transform_io.cpp.

Referenced by loadFullCharacterFromBuffer().

◆ loadMotion()

std::tuple< MotionParameters, IdentityParameters, float > momentum::loadMotion ( const filesystem::path & gltfFilename )

Definition at line 1175 of file gltf_io.cpp.

References MT_THROW.

◆ loadMotionOnCharacter() [1/2]

std::tuple< MatrixXf, VectorXf, float > momentum::loadMotionOnCharacter	(	const filesystem::path &	gltfFilename,
		const Character &	character
	)

Maps the loaded motion onto the input character by matching joint names and parameter names.

This function assumes the file format of the given path is glTF without checking the extension, so please ensure the file is in glTF format.

Parameters

[in]	gltfFilename	The path to the glTF motion file.
[in]	character	The Character object to map the motion onto.

Returns: A tuple containing the motion represented in model parameters, the identity vector represented as joint parameters, and the fps. The model parameters and joint parameters are mapped to the input character by name matching.

Definition at line 1210 of file gltf_io.cpp.

◆ loadMotionOnCharacter() [2/2]

std::tuple< MatrixXf, VectorXf, float > momentum::loadMotionOnCharacter	(	std::span< const std::byte >	byteSpan,
		const Character &	character
	)

Buffer version of loadMotionOnCharacter()

Parameters

[in]	byteSpan	The buffer containing the glTF motion data.
[in]	character	The Character object to map the motion onto.

Returns: A tuple containing the motion represented in model parameters, the identity vector represented as joint parameters, and the fps. The model parameters and joint parameters are mapped to the input character by name matching.

Definition at line 1216 of file gltf_io.cpp.

◆ loadMppca() [1/3]

std::shared_ptr< const Mppca > momentum::loadMppca ( const std::span< const unsigned char > posePriorDataRaw )

Definition at line 18 of file mppca_io.cpp.

References loadMppca().

Referenced by loadMppca(), and loadMppca().

◆ loadMppca() [2/3]

std::shared_ptr< const Mppca > momentum::loadMppca ( const std::string & name )

Definition at line 29 of file mppca_io.cpp.

References loadMppca(), and MT_THROW_IF.

◆ loadMppca() [3/3]

std::shared_ptr< const Mppca > momentum::loadMppca ( std::istream & inputStream )

Definition at line 36 of file mppca_io.cpp.

References MT_THROW, and MT_THROW_IF.

◆ loadOpenFbxCharacter() [1/2]

Character momentum::loadOpenFbxCharacter	(	const filesystem::path &	path,
		KeepLocators	keepLocators,
		bool	permissive,
		LoadBlendShapes	loadBlendShapes,
		bool	stripNamespaces
	)

Definition at line 1299 of file openfbx_loader.cpp.

References loadOpenFbxCharacter().

◆ loadOpenFbxCharacter() [2/2]

Character momentum::loadOpenFbxCharacter	(	const std::span< const std::byte >	inputData,
		KeepLocators	keepLocators,
		bool	permissive,
		LoadBlendShapes	loadBlendShapes,
		bool	stripNamespaces
	)

Definition at line 1288 of file openfbx_loader.cpp.

Referenced by loadFbxCharacter(), loadFbxCharacter(), and loadOpenFbxCharacter().

◆ loadOpenFbxCharacterWithMotion() [1/2]

std::tuple< Character, std::vector< MatrixXf >, float > momentum::loadOpenFbxCharacterWithMotion	(	const filesystem::path &	inputPath,
		KeepLocators	keepLocators,
		bool	permissive,
		LoadBlendShapes	loadBlendShapes,
		bool	stripNamespaces
	)

Definition at line 1323 of file openfbx_loader.cpp.

References loadOpenFbxCharacterWithMotion().

◆ loadOpenFbxCharacterWithMotion() [2/2]

std::tuple< Character, std::vector< MatrixXf >, float > momentum::loadOpenFbxCharacterWithMotion	(	std::span< const std::byte >	inputData,
		KeepLocators	keepLocators,
		bool	permissive,
		LoadBlendShapes	loadBlendShapes,
		bool	stripNamespaces
	)

Definition at line 1314 of file openfbx_loader.cpp.

Referenced by loadFbxCharacterWithMotion(), loadFbxCharacterWithMotion(), and loadOpenFbxCharacterWithMotion().

◆ loadOpenFbxMarkerSequence()

MarkerSequence momentum::loadOpenFbxMarkerSequence	(	const filesystem::path &	filename,
		bool	stripNamespaces
	)

Definition at line 1338 of file openfbx_loader.cpp.

References MT_THROW_IF.

Referenced by loadFbxMarkerSequence().

◆ loadParameters()

void momentum::loadParameters	(	std::unordered_map< std::string, std::string > &	param,
		Character &	character
	)

Definition at line 16 of file parameters_io.cpp.

References momentum::CharacterT< T >::initParameterTransform(), momentum::CharacterT< T >::parameterLimits, momentum::ParameterTransformT< T >::parameterSets, momentum::CharacterT< T >::parameterTransform, parseParameterLimits(), parseParameterSets(), parseParameterTransform(), parsePoseConstraints(), momentum::ParameterTransformT< T >::poseConstraints, and momentum::CharacterT< T >::skeleton.

Referenced by loadFullCharacter(), and loadFullCharacterFromBuffer().

◆ loadPoseShape()

PoseShape momentum::loadPoseShape	(	const std::string &	filename,
		const Character &	character
	)

Loads pose shape data from a binary file.

Parameters

filename	Path to the pose shape data file
character	Character containing skeleton and mesh for validation and joint mapping

Returns: PoseShape with loaded data, or empty PoseShape if file cannot be opened

Definition at line 18 of file pose_shape_io.cpp.

References momentum::PoseShape::baseJoint, momentum::PoseShape::baseRot, momentum::PoseShape::baseShape, momentum::SkeletonT< T >::getJointIdByName(), momentum::PoseShape::jointMap, momentum::SkeletonT< T >::joints, kInvalidIndex, momentum::CharacterT< T >::mesh, MT_CHECK, momentum::PoseShape::shapeVectors, and momentum::CharacterT< T >::skeleton.

◆ loadTrc()

MarkerSequence momentum::loadTrc	(	const std::string &	filename,
		UpVector	up = `UpVector::Y`
	)

Loads marker data from a TRC file into a MarkerSequence.

The function reads the given TRC file and stores the marker data as a MarkerSequence. The unit of the input file will be read from the file and converted to the momentum unit (i.e., cm). The UpVector parameter 'up' is the up-vector convention of the input marker file.

Parameters

[in]	filename	The TRC file to load marker data from.
[in]	up	(Optional) The up-vector convention of the input marker file (default: UpVector::Y).

Returns: MarkerSequence A MarkerSequence containing the marker data from the TRC file.

Definition at line 18 of file trc_io.cpp.

References momentum::MarkerSequence::fps, GetLineCrossPlatform(), tokenize(), and toMomentumVector3().

Referenced by loadMarkers().

◆ loadUrdfCharacter() [1/4]

template<typename T >

CharacterT< T > momentum::loadUrdfCharacter ( const filesystem::path & filepath )

Loads a character from a URDF file.

Definition at line 299 of file urdf_io.cpp.

References MT_THROW.

◆ loadUrdfCharacter() [2/4]

template CharacterT< float > momentum::loadUrdfCharacter ( const filesystem::path & filepath )

◆ loadUrdfCharacter() [3/4]

template<typename T >

CharacterT< T > momentum::loadUrdfCharacter ( std::span< const std::byte > bytes )

Loads a character from a URDF file using the provided byte data.

Definition at line 324 of file urdf_io.cpp.

References MT_THROW.

◆ loadUrdfCharacter() [4/4]

template CharacterT< float > momentum::loadUrdfCharacter ( std::span< const std::byte > bytes )

◆ loadUsdCharacter() [1/2]

Character momentum::loadUsdCharacter ( const filesystem::path & inputPath )

Load a USD character from a local file path.

Parameters

[in] inputPath The path to the USD character file.

Returns: The loaded Character object.

Definition at line 469 of file usd_io.cpp.

References MT_THROW_IF.

◆ loadUsdCharacter() [2/2]

Character momentum::loadUsdCharacter ( std::span< const std::byte > inputSpan )

Load a USD character from a buffer.

Parameters

[in] inputSpan The buffer containing the USD character data.

Returns: The loaded Character object.

Definition at line 479 of file usd_io.cpp.

References MT_THROW_IF.

◆ locatorsToSkinnedLocators()

momentum::Character momentum::locatorsToSkinnedLocators	(	const momentum::Character &	sourceCharacter,
		float	maxDistance = `3.0f`
	)

Convert locators to skinned locators by finding the closest point on the mesh surface that matches the correct bone index and using the skinned weights from that point.

Does not add parameters for the skinned locators, however, that should be a separate step if you are planning to solve for their locations.

Parameters

sourceCharacter	Character with locators to convert
maxDistance	Maximum distance to search for the closest point on the mesh surface. If the locator is further than this distance, it will not be converted.

Definition at line 193 of file tracker_utils.cpp.

References averageTriangleSkinWeights(), closestPointOnMeshMatchingParent(), momentum::SkinnedLocator::name, and momentum::EigenStrongType< Derived, EigenType >::Zero().

◆ logBvh()

void momentum::logBvh	(	const rerun::RecordingStream &	rec,
		const std::string &	streamName,
		const CollisionGeometry &	collisionGeometry,
		const SkeletonState &	skeletonState
	)

Definition at line 289 of file logger.cpp.

References updateAabb().

Referenced by logCollisionGeometry().

◆ logCharacter()

void momentum::logCharacter	(	const rerun::RecordingStream &	rec,
		const std::string &	charStreamName,
		const Character &	character,
		const CharacterState &	characterState,
		const rerun::Color &	color
	)

Definition at line 374 of file logger.cpp.

References momentum::CharacterT< T >::collision, momentum::CharacterT< T >::locators, logCollisionGeometry(), logJoints(), logLocators(), logMesh(), and momentum::CharacterT< T >::skeleton.

◆ logCollisionGeometry()

void momentum::logCollisionGeometry	(	const rerun::RecordingStream &	rec,
		const std::string &	streamName,
		const CollisionGeometry &	collisionGeometry,
		const SkeletonState &	skeletonState
	)

Definition at line 332 of file logger.cpp.

References momentum::SkeletonStateT< T >::jointState, logBvh(), and pi().

Referenced by logCharacter().

◆ logJointParamNames()

void momentum::logJointParamNames	(	const rerun::RecordingStream &	rec,
		const std::string &	worldPrefix,
		const std::string &	posePrefix,
		std::span< const std::string >	names
	)

Definition at line 268 of file logger.cpp.

References kJointParameterNames.

◆ logJointParams()

void momentum::logJointParams	(	const rerun::RecordingStream &	rec,
		const std::string &	worldPrefix,
		const std::string &	posePrefix,
		std::span< const std::string >	names,
		const Eigen::VectorXf &	params
	)

Definition at line 232 of file logger.cpp.

References kJointParameterNames, and kParametersPerJoint.

◆ logJoints()

void momentum::logJoints	(	const rerun::RecordingStream &	rec,
		const std::string &	streamName,
		const Skeleton &	skeleton,
		const JointStateList &	jointStates
	)

Definition at line 67 of file logger.cpp.

References momentum::SkeletonT< T >::getJointNames(), momentum::SkeletonT< T >::joints, kInvalidIndex, and skeleton.

Referenced by logCharacter().

◆ logLevelMap()

std::map< std::string, LogLevel > momentum::logLevelMap ( )

Definition at line 70 of file log.cpp.

References Debug, Disabled, Error, Info, Trace, and Warning.

◆ logLocators()

void momentum::logLocators	(	const rerun::RecordingStream &	rec,
		const std::string &	streamName,
		const LocatorList &	locators,
		const LocatorState &	locatorState
	)

Definition at line 127 of file logger.cpp.

References momentum::LocatorState::position.

Referenced by logCharacter().

◆ logMarkerLocatorCorrespondence()

void momentum::logMarkerLocatorCorrespondence	(	const rerun::RecordingStream &	rec,
		const std::string &	streamName,
		const std::map< std::string, size_t > &	locatorLookup,
		const LocatorState &	locatorState,
		std::span< const Marker >	markers,
		const float	kPositionErrorThreshold
	)

Definition at line 164 of file logger.cpp.

References momentum::LocatorState::position.

◆ logMarkers()

void momentum::logMarkers	(	const rerun::RecordingStream &	rec,
		const std::string &	streamName,
		std::span< const Marker >	markers
	)

Definition at line 103 of file logger.cpp.

◆ logMesh()

void momentum::logMesh	(	const rerun::RecordingStream &	rec,
		const std::string &	streamName,
		const Mesh &	mesh,
		std::optional< rerun::Color >	color = `std::nullopt`
	)

Parameters

[in] (Optional) The color to use for the mesh. If not provided, the colors stored in the mesh are used.

Definition at line 48 of file logger.cpp.

References momentum::MeshT< T >::colors, momentum::MeshT< T >::faces, momentum::MeshT< T >::normals, and momentum::MeshT< T >::vertices.

Referenced by logCharacter().

◆ logModelParamNames()

void momentum::logModelParamNames	(	const rerun::RecordingStream &	rec,
		const std::string &	worldPrefix,
		const std::string &	posePrefix,
		std::span< const std::string >	names
	)

Definition at line 254 of file logger.cpp.

◆ logModelParams()

void momentum::logModelParams	(	const rerun::RecordingStream &	rec,
		const std::string &	worldPrefix,
		const std::string &	posePrefix,
		std::span< const std::string >	names,
		const Eigen::VectorXf &	params
	)

Definition at line 214 of file logger.cpp.

◆ makeAlignedShared()

template<typename T , std::size_t Alignment = alignof(T), class Deleter = AlignedDeleter>

std::shared_ptr< T > momentum::makeAlignedShared	(	std::size_t	n,
		Deleter	deleter = `Deleter()`
	)

Creates a std::shared_ptr for aligned memory.

Definition at line 90 of file aligned.h.

◆ makeAlignedUnique()

template<typename T , std::size_t Alignment = alignof(T), class Deleter = AlignedDeleter>

std::unique_ptr< T, Deleter > momentum::makeAlignedUnique	(	std::size_t	n,
		Deleter	deleter = `Deleter()`
	)

Creates a std::unique_ptr for aligned memory.

Definition at line 82 of file aligned.h.

◆ makeCharacterDocument()

fx::gltf::Document momentum::makeCharacterDocument	(	const Character &	character,
		const float	fps,
		const MotionParameters &	motion,
		const IdentityParameters &	offsets,
		std::span< const std::vector< Marker > >	markerSequence,
		bool	embedResource,
		const FileSaveOptions &	options
	)

Definition at line 1222 of file gltf_io.cpp.

References momentum::SkeletonT< T >::joints, momentum::CharacterT< T >::mesh, and momentum::CharacterT< T >::skeleton.

Referenced by saveCharacterToBytes(), saveGltfCharacter(), and saveGltfCharacter().

◆ mapIdentityToCharacter()

VectorXf momentum::mapIdentityToCharacter	(	const IdentityParameters &	inputIdentity,
		const Character &	targetCharacter
	)

Maps the input JointParameter vector to a target character by matching joint names.

Mismatched names will be discarded (source) or set to zero (target). For every matched joint, all 7 parameters will be copied over.

Parameters

[in]	inputIdentity	Input JointParameter vector with joint names.
[in]	targetCharacter	Target character that defines its own Joints.

Returns: A vector of joint parameters for the target character.

Definition at line 719 of file character_utility.cpp.

References kInvalidIndex, kParametersPerJoint, MT_CHECK, and MT_LOGW.

◆ mapMotionToCharacter() [1/2]

std::tuple< MatrixXf, VectorXf > momentum::mapMotionToCharacter	(	const MatrixXf &	poses,
		const VectorXf &	offsets,
		std::span< const std::string >	parameterNames,
		std::span< const std::string >	jointNames,
		const Character &	character
	)

Map motion data from one parameter space to character parameter space.

Parameters

poses	Source motion poses
offsets	Source joint offsets
parameterNames	Source parameter names
jointNames	Source joint names
character	Target character definition

Returns: Tuple of (mapped poses, mapped offsets)

Definition at line 169 of file mmo_io.cpp.

References momentum::SkeletonT< T >::getJointIdByName(), momentum::SkeletonT< T >::joints, kInvalidIndex, kParametersPerJoint, momentum::ParameterTransformT< T >::name, momentum::ParameterTransformT< T >::numAllModelParameters(), momentum::CharacterT< T >::parameterTransform, and momentum::CharacterT< T >::skeleton.

◆ mapMotionToCharacter() [2/2]

MatrixXf momentum::mapMotionToCharacter	(	const MotionParameters &	inputMotion,
		const Character &	targetCharacter
	)

Maps the input ModelParameter motion to a target character by matching model parameter names.

Mismatched names will be discarded (source) or set to zero (target).

Parameters

[in]	inputMotion	Input ModelParameter motion with names.
[in]	targetCharacter	Target character that defines its own ModelParameters.

Returns: A matrix of model parameters for the target character.

Definition at line 692 of file character_utility.cpp.

References kInvalidIndex, MT_CHECK, and MT_LOGW.

Referenced by loadMmo().

◆ mapParameters()

template<typename T >

Eigen::VectorX< T > momentum::mapParameters	(	const ModelParametersT< T > &	in,
		const std::vector< size_t > &	mp
	)

Definition at line 57 of file pose_prior_error_function.cpp.

References kInvalidIndex.

Referenced by momentum::PosePriorErrorFunctionT< T >::getBestFitMode().

◆ mapParameterTransformJoints() [1/3]

template ParameterTransformT< double > momentum::mapParameterTransformJoints	(	const ParameterTransformT< double > &	paramTransform,
		size_t	numTargetJoints,
		const std::vector< size_t > &	jointMapping
	)

◆ mapParameterTransformJoints() [2/3]

template ParameterTransformT< float > momentum::mapParameterTransformJoints	(	const ParameterTransformT< float > &	paramTransform,
		size_t	numTargetJoints,
		const std::vector< size_t > &	jointMapping
	)

◆ mapParameterTransformJoints() [3/3]

template<typename T >

ParameterTransformT< T > momentum::mapParameterTransformJoints	(	const ParameterTransformT< T > &	parameterTransform,
		size_t	numTargetJoints,
		const std::vector< size_t > &	jointMapping
	)

Construct a new parameter transform where the joints have been mapped to a new skeleton.

Joints that are mapped to kInvalidIndex will be simply skipped. Note that this does not delete any parameters so it's possible if you remove enough joints to have "orphan" parameters still kicking around; to avoid this consider also applying an appropriate subsetParameterTransform() operation.

Definition at line 230 of file parameter_transform.cpp.

◆ MOMENTUM_FWD_DECLARE_TEMPLATE_CLASS() [1/2]

momentum::MOMENTUM_FWD_DECLARE_TEMPLATE_CLASS ( DistanceErrorFunction )

◆ MOMENTUM_FWD_DECLARE_TEMPLATE_CLASS() [2/2]

momentum::MOMENTUM_FWD_DECLARE_TEMPLATE_CLASS ( FullyDifferentiableProjectionErrorFunction )

◆ MOMENTUM_FWD_DECLARE_TEMPLATE_STRUCT()

momentum::MOMENTUM_FWD_DECLARE_TEMPLATE_STRUCT ( DistanceConstraintData )

◆ mppcaToJson()

void momentum::mppcaToJson	(	const Character &	character,
		nlohmann::json &	j
	)

◆ nan()

template<typename T = float>

constexpr T momentum::nan ( )

constexprnoexcept

Definition at line 16 of file constants.h.

◆ normal() [1/4]

template<typename T >

T momentum::normal	(	const T &	mean,
		const T &	sigma
	)

Generates a random type T from the Gaussian distribution, using the global random number generator Random.

Definition at line 374 of file random-inl.h.

References momentum::Random< Generator_ >::GetSingleton().

Referenced by momentum::SimdNormalConstraints::addConstraint(), momentum::NormalErrorFunctionT< T >::evalFunction(), momentum::SimdPlaneErrorFunction::getError(), momentum::SimdNormalErrorFunction::getError(), momentum::PointTriangleVertexErrorFunctionT< T >::getError(), momentum::VertexErrorFunctionT< T >::getError(), momentum::SimdNormalErrorFunction::getGradient(), and momentum::MeshT< T >::updateNormals().

◆ normal() [2/4]

template<typename DynamicMatrix >

DynamicMatrix momentum::normal	(	Eigen::Index	rows,
		Eigen::Index	cols,
		typename DynamicMatrix::Scalar	mean,
		typename DynamicMatrix::Scalar	sigma
	)

Generates a random dynamic size matrix from the Gaussian distribution, using the global random number generator Random.

Definition at line 395 of file random-inl.h.

References momentum::Random< Generator_ >::GetSingleton().

◆ normal() [3/4]

template<typename DynamicVector >

DynamicVector momentum::normal	(	Eigen::Index	size,
		typename DynamicVector::Scalar	mean,
		typename DynamicVector::Scalar	sigma
	)

Generates a random dynamic size vector from the Gaussian distribution, using the global random number generator Random.

Definition at line 386 of file random-inl.h.

References momentum::Random< Generator_ >::GetSingleton().

◆ normal() [4/4]

template<typename FixedSizeT >

FixedSizeT momentum::normal	(	typename FixedSizeT::Scalar	mean,
		typename FixedSizeT::Scalar	sigma
	)

Generates a random fixed size vector/matrix from the Gaussian distribution, using the global random number generator Random.

Definition at line 380 of file random-inl.h.

References momentum::Random< Generator_ >::GetSingleton().

◆ operator!=()

template<class T , class U , std::size_t Alignment>

bool momentum::operator!=	(	const AlignedAllocator< T, Alignment > &	,
		const AlignedAllocator< U, Alignment > &
	)

Checks if storage allocated from lhs cannot be deallocated from rhs, and vice versa.

This always returns false for stateless allocators.

Definition at line 149 of file aligned.h.

◆ operator*() [1/4]

template<typename S , typename Derived >

Vector3P< S > momentum::operator*	(	const Eigen::MatrixBase< Derived > &	xf,
		const Vector3P< S > &	vec
	)

Calculates multiplication of 3x3 matrix and each 3x1 vector in packet.

Template Parameters

Derived A derived class of Eigen::MatrixBase, which should be compatible with Eigen::Matrix3f.

Parameters

[in]	xf	A 3x3 matrix.
[in]	vec	A 3-vector of packets.

Definition at line 168 of file simd.h.

References dot().

◆ operator*() [2/4]

template<typename S >

Vector3P< S > momentum::operator*	(	const Eigen::Quaternion< S > &	q,
		const Vector3P< S > &	vec
	)

Calculates multiplication of quaternion and each 3x1 vector in packet.

Parameters

[in]	q	A quaternion.
[in]	vec	A 3-vector of packets.

Definition at line 157 of file simd.h.

Referenced by momentum::SimdPlaneErrorFunction::getError(), momentum::SimdNormalErrorFunction::getError(), and momentum::SimdNormalErrorFunction::getGradient().

◆ operator*() [3/4]

template<typename S >

Vector3P< S > momentum::operator*	(	const Eigen::Transform< S, 3, Eigen::Affine > &	xf,
		const Vector3P< S > &	vec
	)

Calculates affine transformation on each 3x1 vector in packet.

Parameters

[in]	xf	An affine transformation matrix.
[in]	vec	A 3-vector of packets.

Definition at line 178 of file simd.h.

References operator+().

◆ operator*() [4/4]

template<typename S >

Vector3P< S > momentum::operator*	(	const TransformT< S > &	xf,
		const Vector3P< S > &	vec
	)

Calculates transformation on each 3x1 vector in packet using momentum::Transform.

Parameters

[in]	xf	A momentum transform.
[in]	vec	A 3-vector of packets.

Definition at line 187 of file simd.h.

References operator+().

◆ operator+() [1/2]

template<typename S , typename Derived >

Vector3P< S > momentum::operator+	(	const Eigen::MatrixBase< Derived > &	v1,
		const Vector3P< S > &	v2
	)

Calculates summation of Eigen::Vector3f and Vector3P.

Template Parameters

Derived A derived class of Eigen::MatrixBase, which should be compatible with Eigen::Vector3f.

Parameters

[in]	v1	A 3D vector of Eigen.
[in]	v2	A 3-vector of packets.

Definition at line 115 of file simd.h.

Referenced by operator*(), and operator*().

◆ operator+() [2/2]

template<typename S , typename Derived >

Vector3P< S > momentum::operator+	(	const Vector3P< S > &	v1,
		const Eigen::MatrixBase< Derived > &	v2
	)

Calculates summation of Vector3P and Eigen::Vector3f.

Template Parameters

Derived A derived class of Eigen::MatrixBase, which should be compatible with Eigen::Vector3f.

Parameters

[in]	v1	A 3-vector of packets.
[in]	v2	A 3D vector of Eigen.

Definition at line 126 of file simd.h.

◆ operator-() [1/2]

template<typename S , typename Derived >

Vector3P< S > momentum::operator-	(	const Eigen::MatrixBase< Derived > &	v1,
		const Vector3P< S > &	v2
	)

Calculates subtraction of Eigen::Vector3f and Vector3P.

Template Parameters

Derived A derived class of Eigen::MatrixBase, which should be compatible with Eigen::Vector3f.

Parameters

[in]	v1	A 3D vector of Eigen.
[in]	v2	A 3-vector of packets.

Definition at line 137 of file simd.h.

Referenced by momentum::SimdNormalErrorFunction::getGradient().

◆ operator-() [2/2]

template<typename S , typename Derived >

Vector3P< S > momentum::operator-	(	const Vector3P< S > &	v1,
		const Eigen::MatrixBase< Derived > &	v2
	)

Calculates subtraction of Vector3P and Eigen::Vector3f.

Template Parameters

Derived A derived class of Eigen::MatrixBase, which should be compatible with Eigen::Vector3f.

Parameters

[in]	v1	A 3-vector of packets.
[in]	v2	A 3D vector of Eigen.

Definition at line 148 of file simd.h.

◆ operator==()

template<class T , class U , std::size_t Alignment>

bool momentum::operator==	(	const AlignedAllocator< T, Alignment > &	,
		const AlignedAllocator< U, Alignment > &
	)

Checks if storage allocated from lhs can be deallocated from rhs, and vice versa.

This always returns true for stateless allocators.

Definition at line 139 of file aligned.h.

◆ overlaps()

template<typename T >

bool momentum::overlaps	(	const Vector3< T > &	originA,
		const Vector3< T > &	directionA,
		const Vector2< T > &	radiiA,
		T	deltaA,
		const Vector3< T > &	originB,
		const Vector3< T > &	directionB,
		const Vector2< T > &	radiiB,
		T	deltaB,
		T &	outDistance,
		Vector2< T > &	outClosestPoints,
		T &	outOverlap
	)

Determines if two tapered capsules overlap.

Parameters

originA	Origin of the first capsule
directionA	Direction vector of the first capsule
radiiA	Radii at the endpoints of the first capsule
deltaA	Difference between radii of the first capsule
originB	Origin of the second capsule
directionB	Direction vector of the second capsule
radiiB	Radii at the endpoints of the second capsule
deltaB	Difference between radii of the second capsule
outDistance	Output parameter for the distance between the closest points (normalized). No modification on return false.
outOverlap	Output parameter for the overlap amount (positive if overlapping)

Returns: True if the capsules overlap, false otherwise

Definition at line 67 of file collision_geometry_state.h.

◆ parameterLimitsFromJson()

ParameterLimits momentum::parameterLimitsFromJson	(	const Character &	character,
		const nlohmann::json &	j
	)

◆ parameterLimitsToJson()

void momentum::parameterLimitsToJson	(	const Character &	character,
		nlohmann::json &	j
	)

◆ parameterSetsFromJson()

ParameterSets momentum::parameterSetsFromJson	(	const Character &	character,
		const nlohmann::json &	j
	)

Definition at line 31 of file json_utils.cpp.

References momentum::ParameterTransformT< T >::getParameterIdByName(), kInvalidIndex, and momentum::CharacterT< T >::parameterTransform.

◆ parameterSetsToJson()

void momentum::parameterSetsToJson	(	const Character &	character,
		nlohmann::json &	j
	)

Definition at line 19 of file json_utils.cpp.

References momentum::ParameterTransformT< T >::name, momentum::ParameterTransformT< T >::parameterSets, and momentum::CharacterT< T >::parameterTransform.

Referenced by momentum::GltfBuilder::addCharacter().

◆ parameterTransformFromJson()

ParameterTransform momentum::parameterTransformFromJson	(	const Character &	character,
		const nlohmann::json &	j
	)

Definition at line 102 of file json_utils.cpp.

References momentum::ParameterTransformT< T >::activeJointParams, momentum::SkeletonT< T >::getJointIdByName(), momentum::SkeletonT< T >::getJointNames(), momentum::ParameterTransformT< float >::identity(), momentum::SkeletonT< T >::joints, kInvalidIndex, kJointParameterNames, kParametersPerJoint, MT_THROW_IF, momentum::CharacterT< T >::skeleton, and triplets.

◆ parameterTransformToJson()

void momentum::parameterTransformToJson	(	const Character &	character,
		nlohmann::json &	j
	)

Definition at line 80 of file json_utils.cpp.

References momentum::SkeletonT< T >::joints, kJointParameterNames, kParametersPerJoint, momentum::ParameterTransformT< T >::name, momentum::CharacterT< T >::parameterTransform, momentum::CharacterT< T >::skeleton, and momentum::ParameterTransformT< T >::transform.

Referenced by momentum::GltfBuilder::addCharacter().

◆ parseParameterLimits() [1/2]

ParameterLimits momentum::parseParameterLimits	(	const io_detail::SectionContent &	content,
		const Skeleton &	skeleton,
		const ParameterTransform &	parameterTransform
	)

Definition at line 615 of file parameter_limits_io.cpp.

References momentum::io_detail::SectionContent::begin(), momentum::io_detail::SectionContent::LineIterator::currentLine(), MT_LOGW, MT_LOGW_ONCE, MT_THROW, MT_THROW_IF, parameterTransform, skeleton, and trim().

Referenced by loadParameters(), and parseParameterLimits().

◆ parseParameterLimits() [2/2]

ParameterLimits momentum::parseParameterLimits	(	const std::string &	data,
		const Skeleton &	skeleton,
		const ParameterTransform &	parameterTransform,
		size_t	lineOffset
	)

Definition at line 685 of file parameter_limits_io.cpp.

References momentum::io_detail::SectionContent::addSegment(), parameterTransform, parseParameterLimits(), and skeleton.

◆ parseParameterSets() [1/3]

ParameterSets momentum::parseParameterSets	(	const io_detail::SectionContent &	content,
		const ParameterTransform &	pt
	)

◆ parseParameterSets() [2/3]

ParameterSets momentum::parseParameterSets	(	const SectionContent &	content,
		const ParameterTransform &	pt
	)

Definition at line 392 of file parameter_transform_io.cpp.

References kInvalidIndex, MT_LOGW, MT_THROW_IF, tokenize(), and trim().

Referenced by loadParameters(), and parseParameterSets().

◆ parseParameterSets() [3/3]

ParameterSets momentum::parseParameterSets	(	const std::string &	data,
		const ParameterTransform &	pt,
		size_t	lineOffset
	)

Definition at line 452 of file parameter_transform_io.cpp.

References parseParameterSets().

◆ parseParameterTransform() [1/3]

ParameterTransform momentum::parseParameterTransform	(	const io_detail::SectionContent &	content,
		const Skeleton &	skeleton
	)

◆ parseParameterTransform() [2/3]

ParameterTransform momentum::parseParameterTransform	(	const SectionContent &	content,
		const Skeleton &	skeleton
	)

Definition at line 291 of file parameter_transform_io.cpp.

References momentum::ParameterTransformT< T >::activeJointParams, momentum::SkeletonT< T >::getJointIdByName(), momentum::SkeletonT< T >::joints, kInvalidIndex, kJointParameterNames, kParametersPerJoint, MT_LOGW, MT_THROW_IF, skeleton, tokenize(), trim(), and triplets.

Referenced by loadParameters(), and parseParameterTransform().

◆ parseParameterTransform() [3/3]

ParameterTransform momentum::parseParameterTransform	(	const std::string &	data,
		const Skeleton &	skeleton,
		size_t	lineOffset
	)

Definition at line 383 of file parameter_transform_io.cpp.

References parseParameterTransform(), and skeleton.

◆ parsePoseConstraints() [1/3]

PoseConstraints momentum::parsePoseConstraints	(	const io_detail::SectionContent &	content,
		const ParameterTransform &	pt
	)

◆ parsePoseConstraints() [2/3]

PoseConstraints momentum::parsePoseConstraints	(	const SectionContent &	content,
		const ParameterTransform &	pt
	)

Definition at line 461 of file parameter_transform_io.cpp.

References kInvalidIndex, MT_LOGW, MT_THROW_IF, tokenize(), and trim().

Referenced by loadParameters(), and parsePoseConstraints().

◆ parsePoseConstraints() [3/3]

PoseConstraints momentum::parsePoseConstraints	(	const std::string &	data,
		const ParameterTransform &	pt,
		size_t	lineOffset
	)

Definition at line 526 of file parameter_transform_io.cpp.

References parsePoseConstraints().

◆ pi()

template<typename T = float>

constexpr T momentum::pi ( )

constexprnoexcept

Definition at line 36 of file constants.h.

Referenced by logCollisionGeometry(), momentum::FullyDifferentiablePosePriorErrorFunctionT< T >::setPosePrior(), and momentum::PoseTransformSolverT< T >::transformPose().

◆ poseConstraintsFromJson()

PoseConstraints momentum::poseConstraintsFromJson	(	const Character &	character,
		const nlohmann::json &	j
	)

Definition at line 61 of file json_utils.cpp.

References momentum::ParameterTransformT< T >::getParameterIdByName(), kInvalidIndex, and momentum::CharacterT< T >::parameterTransform.

◆ poseConstraintsToJson()

void momentum::poseConstraintsToJson	(	const Character &	character,
		nlohmann::json &	j
	)

Definition at line 49 of file json_utils.cpp.

References momentum::ParameterTransformT< T >::name, momentum::CharacterT< T >::parameterTransform, and momentum::ParameterTransformT< T >::poseConstraints.

Referenced by momentum::GltfBuilder::addCharacter().

◆ processMarkerFile()

void momentum::processMarkerFile	(	const std::string &	inputMarkerFile,
		const std::string &	outputFile,
		const TrackingConfig &	trackingConfig,
		const CalibrationConfig &	calibrationConfig,
		const ModelOptions &	modelOptions,
		bool	calibrate,
		size_t	firstFrame = `0`,
		size_t	maxFrames = `0`
	)

Runs marker tracking on an input marker file (e.g.

c3d) and writes the output motion (e.g. glb) to outputFile

Definition at line 68 of file process_markers.cpp.

References findMainSubjectIndex(), loadCharacterWithIdentity(), loadMarkers(), MT_LOGE, MT_LOGI, processMarkers(), saveMotion(), and Y.

◆ processMarkers()

Eigen::MatrixXf momentum::processMarkers	(	momentum::Character &	character,
		momentum::ModelParameters &	identity,
		const std::vector< std::vector< momentum::Marker > > &	markerData,
		const TrackingConfig &	trackingConfig,
		const CalibrationConfig &	calibrationConfig,
		bool	calibrate = `true`,
		size_t	firstFrame = `0`,
		size_t	maxFrames = `0`
	)

Processes marker data for a character model.

It can calibrate the model and locators based on the calibrationConfig, and track the motion of the markers.

Parameters

[in,out]	character	The input character definition with locators. It also holds the output locators if locators are to be calibrated from the calibrationConfig.
[in,out]	identity	The input identity used for tracking. It also holds the solved identify if identity is to be calibrated from the calibrationConfig.
[in]	markerData	The per-frame position targets to be tracked.
[in]	trackingConfig	The config for per-frame tracking after the correct identity and locators are solved for (or from input).
[in]	calibrationConfig	The config for running calibration if calibrate is set to true.
[in]	calibrate	True to run calibration according to calibrationConfig.
[in]	firstFrame	The first frame to start solving. We pass in the first frame instead of triming markerData to avoid data copy.
[in]	maxFrames	The maximum number of frames to process starting from firstFrame.

Returns: The final motion matrix after tracking.

Definition at line 23 of file process_markers.cpp.

References calibrateLocators(), calibrateModel(), getLocatorError(), MT_CHECK, MT_LOGI, MT_THROW_IF, and trackPosesPerframe().

Referenced by processMarkerFile().

◆ pseudoInverse() [1/6]

template MatrixX< double > momentum::pseudoInverse ( const MatrixX< double > & mat )

◆ pseudoInverse() [2/6]

template MatrixX< float > momentum::pseudoInverse ( const MatrixX< float > & mat )

◆ pseudoInverse() [3/6]

template<typename T >

MatrixX< T > momentum::pseudoInverse ( const MatrixX< T > & mat )

Calculates the pseudo-inverse of a matrix.

Uses singular value decomposition (SVD) to compute the Moore-Penrose pseudo-inverse

Template Parameters

T	The scalar type

Parameters

mat	Input matrix

Returns: The pseudo-inverse of the input matrix

Definition at line 414 of file utility.cpp.

Referenced by pseudoInverse().

◆ pseudoInverse() [4/6]

template MatrixX< double > momentum::pseudoInverse ( const SparseMatrix< double > & mat )

◆ pseudoInverse() [5/6]

template MatrixX< float > momentum::pseudoInverse ( const SparseMatrix< float > & mat )

◆ pseudoInverse() [6/6]

template<typename T >

MatrixX< T > momentum::pseudoInverse ( const SparseMatrix< T > & mat )

Calculates the pseudo-inverse of a sparse matrix.

Converts the sparse matrix to a dense matrix before computing the pseudo-inverse

Template Parameters

T	The scalar type

Parameters

mat	Input sparse matrix

Returns: The pseudo-inverse as a dense matrix

Definition at line 429 of file utility.cpp.

References pseudoInverse().

◆ quaternionAverage()

Quaternionf momentum::quaternionAverage	(	std::span< const Quaternionf >	q,
		std::span< const float >	w = `std::vector< float >()`
	)

Computes the weighted average of multiple quaternions.

Uses the method described in Markley et al. "Averaging Quaternions"

Parameters

q	Array of quaternions to average
w	Optional weights for each quaternion (defaults to equal weights)

Returns: The average quaternion

Definition at line 397 of file utility.cpp.

◆ quaternionExpMap() [1/3]

template Quaternion< double > momentum::quaternionExpMap ( const Vector3< double > & v )

◆ quaternionExpMap() [2/3]

template Quaternion< float > momentum::quaternionExpMap ( const Vector3< float > & v )

◆ quaternionExpMap() [3/3]

template<typename T >

Quaternion< T > momentum::quaternionExpMap ( const Vector3< T > & v )

Computes the exponential map from a rotation vector (axis-angle in R^3) to a quaternion.

The exponential map takes a 3D rotation vector (where the direction is the rotation axis and the magnitude is the rotation angle in radians) and returns the corresponding unit quaternion. This is numerically robust for small angles using Taylor series expansion.

Reference: "Practical Parameterization of Rotations Using the Exponential Map" by F. Sebastian Grassia, Journal of Graphics Tools, 1998.

Template Parameters

T	The scalar type

Parameters

v	The rotation vector (axis-angle representation)

Returns: The corresponding unit quaternion

Definition at line 32 of file utility.cpp.

◆ quaternionLogMap() [1/3]

template Vector3< double > momentum::quaternionLogMap ( const Quaternion< double > & q )

◆ quaternionLogMap() [2/3]

template Vector3< float > momentum::quaternionLogMap ( const Quaternion< float > & q )

◆ quaternionLogMap() [3/3]

template<typename T >

Vector3< T > momentum::quaternionLogMap ( const Quaternion< T > & q )

Computes the logarithmic map from a quaternion to a rotation vector (axis-angle in R^3).

The logarithmic map takes a unit quaternion and returns the corresponding 3D rotation vector (where the direction is the rotation axis and the magnitude is the rotation angle in radians). This is numerically robust for small angles using Taylor series expansion. For quaternions close to -I (180 degree rotation), a consistent branch is chosen.

Reference: "Practical Parameterization of Rotations Using the Exponential Map" by F. Sebastian Grassia, Journal of Graphics Tools, 1998.

Template Parameters

T	The scalar type

Parameters

q	The input quaternion (should be normalized)

Returns: The corresponding rotation vector (axis-angle representation)

Definition at line 71 of file utility.cpp.

Referenced by momentum::StateErrorFunctionT< T >::getError(), momentum::StateSequenceErrorFunctionT< T >::getError(), momentum::StateErrorFunctionT< T >::getGradient(), momentum::StateSequenceErrorFunctionT< T >::getGradient(), momentum::StateErrorFunctionT< T >::getJacobian(), and momentum::StateSequenceErrorFunctionT< T >::getJacobian().

◆ quaternionLogMapDerivative() [1/3]

template Eigen::Matrix< double, 3, 4 > momentum::quaternionLogMapDerivative ( const Quaternion< double > & q )

◆ quaternionLogMapDerivative() [2/3]

template Eigen::Matrix< float, 3, 4 > momentum::quaternionLogMapDerivative ( const Quaternion< float > & q )

◆ quaternionLogMapDerivative() [3/3]

template<typename T >

Eigen::Matrix< T, 3, 4 > momentum::quaternionLogMapDerivative ( const Quaternion< T > & q )

Computes the derivative of the logmap with respect to quaternion components.

Computes the derivative of the logarithmic map with respect to quaternion components.

Given a quaternion q with coeffs [x, y, z, w], computes the Jacobian matrix J where: J(i,j) = d(log(q)[i]) / dq.coeffs()[j] where log(q) is the 3D rotation vector and q.coeffs() = [x, y, z, w].

Reference: "Practical Parameterization of Rotations Using the Exponential Map" by F. Sebastian Grassia, Journal of Graphics Tools, 1998. https://www.cs.cmu.edu/~spiff/moedit99/expmap.pdf

Template Parameters

T	The scalar type

Parameters

q	The input quaternion (should be normalized)

Returns: 3x4 Jacobian matrix where column j is the gradient w.r.t. q.coeffs()[j] i.e., columns are ordered as [d/dx, d/dy, d/dz, d/dw]

Given a quaternion q with coeffs [x, y, z, w], computes the Jacobian matrix J where: J(i,j) = d(log(q)[i]) / dq.coeffs()[j] where log(q) is the 3D rotation vector and q.coeffs() = [x, y, z, w] (Eigen's convention).

This is the fundamental building block for computing derivatives of functions involving logmap through the chain rule.

Reference: "Practical Parameterization of Rotations Using the Exponential Map" by F. Sebastian Grassia, Journal of Graphics Tools, 1998.

Template Parameters

T	The scalar type

Parameters

q	The input quaternion (should be normalized)

Returns: 3x4 Jacobian matrix where column j is the gradient w.r.t. q.coeffs()[j], i.e., columns are ordered as [d/dx, d/dy, d/dz, d/dw]

Definition at line 127 of file utility.cpp.

Referenced by momentum::StateErrorFunctionT< T >::getGradient(), momentum::StateSequenceErrorFunctionT< T >::getGradient(), momentum::StateErrorFunctionT< T >::getJacobian(), and momentum::StateSequenceErrorFunctionT< T >::getJacobian().

◆ quaternionToEuler() [1/3]

template<typename T >

Vector3< T > momentum::quaternionToEuler ( const Quaternion< T > & q )

Converts a quaternion to Euler angles using the Extrinsic XYZ convention.

The returned angles [x, y, z] are such that applying Extrinsic rotations RotX(x) then RotY(y) then RotZ(z) (i.e., about fixed world axes) reproduces the input quaternion's rotation. Empirically verified by tests.

Note: This matches the convention used in skeleton_state (skel_state): Extrinsic XYZ.

Template Parameters

T	The scalar type

Parameters

q	Input quaternion

Returns: Vector of Euler angles [x, y, z]

Definition at line 387 of file utility.cpp.

References sqr().

◆ quaternionToEuler() [2/3]

template Vector3d momentum::quaternionToEuler ( const Quaterniond & q )

◆ quaternionToEuler() [3/3]

template Vector3f momentum::quaternionToEuler ( const Quaternionf & q )

◆ redirectLogsToRerun()

bool momentum::redirectLogsToRerun ( const rerun::RecordingStream & rec )

Redirects logs from the XR_LOG framework to the Rerun logger.

This function registers a custom log sink for the XR_LOG framework, redirecting its log messages to the Rerun logger. The redirection is only performed once, and subsequent calls to this function have no effect.

Parameters

[in] rec The recording stream to which to write the logs. You should make sure the lifetime of this is longer than the loggings from momentum libraries.

Returns: Returns true if the redirection is successful or has already been done.

Definition at line 70 of file logging_redirect.cpp.

References MT_LOGW.

◆ reduceMeshByFaces()

template<typename T >

CharacterT< T > momentum::reduceMeshByFaces	(	const CharacterT< T > &	character,
		const std::vector< bool > &	activeFaces
	)

Reduces the mesh to only include the specified faces and associated vertices.

Parameters

[in]	character	Character to be reduced
[in]	activeFaces	Boolean vector indicating which faces to keep

Returns: A new character with mesh reduced to the specified faces

Definition at line 1114 of file character_utility.cpp.

References facesToVertices(), momentum::CharacterT< T >::mesh, and MT_CHECK.

◆ reduceMeshByFaces< double >()

template CharacterT< double > momentum::reduceMeshByFaces< double >	(	const CharacterT< double > &	character,
		const std::vector< bool > &	activeFaces
	)

◆ reduceMeshByFaces< float >()

template CharacterT< float > momentum::reduceMeshByFaces< float >	(	const CharacterT< float > &	character,
		const std::vector< bool > &	activeFaces
	)

◆ reduceMeshByVertices()

template<typename T >

CharacterT< T > momentum::reduceMeshByVertices	(	const CharacterT< T > &	character,
		const std::vector< bool > &	activeVertices
	)

Reduces the mesh to only include the specified vertices and associated faces.

Parameters

[in]	character	Character to be reduced
[in]	activeVertices	Boolean vector indicating which vertices to keep

Returns: A new character with mesh reduced to the specified vertices

Definition at line 1097 of file character_utility.cpp.

References momentum::CharacterT< T >::mesh, MT_CHECK, and verticesToFaces().

◆ reduceMeshByVertices< double >()

template CharacterT< double > momentum::reduceMeshByVertices< double >	(	const CharacterT< double > &	character,
		const std::vector< bool > &	activeVertices
	)

◆ reduceMeshByVertices< float >()

template CharacterT< float > momentum::reduceMeshByVertices< float >	(	const CharacterT< float > &	character,
		const std::vector< bool > &	activeVertices
	)

◆ refineMotion() [1/2]

Eigen::MatrixXf momentum::refineMotion	(	std::span< const std::vector< momentum::Marker > >	markerData,
		const Eigen::MatrixXf &	motion,
		const RefineConfig &	config,
		momentum::Character &	character
	)

◆ refineMotion() [2/2]

MatrixXf momentum::refineMotion	(	std::span< const std::vector< momentum::Marker > >	markerData,
		const MatrixXf &	motion,
		const RefineConfig &	config,
		momentum::Character &	character
	)

Refine existing motion by smoothing and optionally recalibrating identity/locators.

This is a post-processing function that takes an already tracked motion and improves it by applying temporal smoothness constraints, and optionally recalibrating character identity or locator positions. It uses the sequence solver to enforce temporal coherence across frames.

Parameters

markerData	Marker observations for each frame
motion	Initial motion to refine (parameters x frames)
config	Refinement configuration settings
character	Character model (may be modified if calibration is enabled)

Returns: Refined motion parameters matrix with improved temporal consistency

Definition at line 1075 of file marker_tracker.cpp.

References createLocatorCharacter(), extractIdAndLocatorsFromParams(), momentum::ParameterTransformT< T >::getScalingParameters(), momentum::CharacterT< T >::locators, MT_CHECK, momentum::ParameterTransformT< T >::numAllModelParameters(), momentum::ParameterTransformT< T >::parameterSets, momentum::CharacterT< T >::parameterTransform, momentum::CharacterT< T >::skinnedLocators, and trackSequence().

◆ removeIdentity()

void momentum::removeIdentity	(	const ParameterSet &	idSet,
		const ModelParameters &	identity,
		Eigen::MatrixXf &	motionWithId
	)

Definition at line 523 of file tracker_utils.cpp.

References momentum::EigenStrongType< Derived, EigenType >::v.

Referenced by saveMotion().

◆ removeJoints()

Character momentum::removeJoints	(	const Character &	character,
		std::span< const size_t >	jointsToRemove
	)

Removes the specified joints and any joints parented beneath them from the character.

Currently, it is necessary to remove child joints to prevent dangling joints. Mesh points skinned to the removed joints are re-skinned to their parent joint in the hierarchy.

Parameters

[in]	character	The character from which joints will be removed.
[in]	jointsToRemove	A vector of joint indices to be removed.

Returns: A new Character object that is identical to the original except for the removal of specified joints.

Definition at line 601 of file character_utility.cpp.

◆ replaceSkeletonHierarchy()

Character momentum::replaceSkeletonHierarchy	(	const Character &	srcCharacter,
		const Character &	tgtCharacter,
		const std::string &	srcRootJoint,
		const std::string &	tgtRootJoint
	)

Replaces the part of target_character's skeleton rooted at target_root with the part of source_character's skeleton rooted at source_root.

This function is typically used to swap one character's hand skeleton with another, for example.

Parameters

[in]	srcCharacter	The source character whose skeleton will be copied.
[in]	tgtCharacter	The target character whose skeleton will be replaced.
[in]	srcRootJoint	Root of the source skeleton hierarchy to be copied.
[in]	tgtRootJoint	Root of the target skeleton hierarchy to be replaced.

Returns: A new Character that is identical to tgtCharacter except that the skeleton under tgtRootJoint has been replaced by the part of srcCharacter's skeleton rooted at srcRootJoint.

Definition at line 440 of file character_utility.cpp.

References momentum::SkeletonT< T >::joints, kInvalidIndex, kParametersPerJoint, MT_CHECK, MT_LOGW_IF, MT_THROW_IF, momentum::ParameterTransformT< T >::offsets, and skeleton.

◆ rotationMatrixToEuler() [1/3]

template Vector3< double > momentum::rotationMatrixToEuler	(	const Matrix3< double > &	m,
		int	axis0,
		int	axis1,
		int	axis2,
		EulerConvention	convention
	)

◆ rotationMatrixToEuler() [2/3]

template Vector3< float > momentum::rotationMatrixToEuler	(	const Matrix3< float > &	m,
		int	axis0,
		int	axis1,
		int	axis2,
		EulerConvention	convention
	)

◆ rotationMatrixToEuler() [3/3]

template<typename T >

Vector3< T > momentum::rotationMatrixToEuler	(	const Matrix3< T > &	m,
		int	axis0,
		int	axis1,
		int	axis2,
		EulerConvention	convention = `EulerConvention::Intrinsic`
	)

Converts rotation matrix to Euler angles.

Template Parameters

T	The scalar type.

Parameters

[in]	m	The rotation matrix to convert.
[in]	axis0	The index of the first rotation's axis, one of {0, 1, 2}.
[in]	axis1	The index of the second rotation's axis, one of {0, 1, 2}.
[in]	axis2	The index of the third rotation's axis, one of {0, 1, 2}.
[in]	convention	The Euler angles convention.

Definition at line 194 of file utility.cpp.

References Extrinsic, Intrinsic, and rotationMatrixToEuler().

Referenced by rotationMatrixToEuler().

◆ rotationMatrixToEulerXYZ() [1/3]

template Vector3< double > momentum::rotationMatrixToEulerXYZ	(	const Matrix3< double > &	m,
		EulerConvention	convention
	)

◆ rotationMatrixToEulerXYZ() [2/3]

template Vector3< float > momentum::rotationMatrixToEulerXYZ	(	const Matrix3< float > &	m,
		EulerConvention	convention
	)

◆ rotationMatrixToEulerXYZ() [3/3]

template<typename T >

Vector3< T > momentum::rotationMatrixToEulerXYZ	(	const Matrix3< T > &	m,
		EulerConvention	convention
	)

An optimized version of rotationMatrixToEuler(m, 0, 1, 2, convention) or rotationMatrixToEuler(m, 2, 1, 0, convention).reverse().

Definition at line 208 of file utility.cpp.

References Extrinsic, Intrinsic, and rotationMatrixToEulerZYX().

Referenced by rotationMatrixToEulerZYX(), and writeParameterLimits().

◆ rotationMatrixToEulerZYX() [1/3]

template Vector3< double > momentum::rotationMatrixToEulerZYX	(	const Matrix3< double > &	m,
		EulerConvention	convention
	)

◆ rotationMatrixToEulerZYX() [2/3]

template Vector3< float > momentum::rotationMatrixToEulerZYX	(	const Matrix3< float > &	m,
		EulerConvention	convention
	)

◆ rotationMatrixToEulerZYX() [3/3]

template<typename T >

Vector3< T > momentum::rotationMatrixToEulerZYX	(	const Matrix3< T > &	m,
		EulerConvention	convention
	)

An optimized version of rotationMatrixToEuler(m, 2, 1, 0, convention) or rotationMatrixToEuler(m, 0, 1, 2, convention).reverse().

Definition at line 249 of file utility.cpp.

References Extrinsic, Intrinsic, and rotationMatrixToEulerXYZ().

Referenced by momentum::JointParametersT< T >::fromRotationMatrix(), and rotationMatrixToEulerXYZ().

◆ rotationMatrixToOneAxisEuler() [1/3]

template double momentum::rotationMatrixToOneAxisEuler	(	const Matrix3< double > &	m,
		int	axis0
	)

◆ rotationMatrixToOneAxisEuler() [2/3]

template float momentum::rotationMatrixToOneAxisEuler	(	const Matrix3< float > &	m,
		int	axis0
	)

◆ rotationMatrixToOneAxisEuler() [3/3]

template<typename T >

T momentum::rotationMatrixToOneAxisEuler	(	const Matrix3< T > &	m,
		int	axis0
	)

Fits a single-axis Euler rotation to a rotation matrix.

Finds the best-fit single-axis rotation angle that minimizes the L2 distance to the target rotation matrix using Levenberg-Marquardt optimization. This is NOT a direct conversion - if the input matrix cannot be exactly represented as a single-axis rotation, this function returns the closest approximation.

For exact single-axis rotations, the result will be precise. For general rotation matrices (e.g., those involving rotations around multiple axes), the result is the best single-axis approximation in the least-squares sense.

Template Parameters

T	The scalar type.

Parameters

[in]	m	The target rotation matrix.
[in]	axis0	The rotation axis index, one of {0, 1, 2} (X, Y, Z).

Returns: The fitted rotation angle around the specified axis.

Definition at line 785 of file utility.cpp.

References MT_CHECK.

Referenced by rotationMatrixToTwoAxisEuler().

◆ rotationMatrixToTwoAxisEuler() [1/3]

template Vector2< double > momentum::rotationMatrixToTwoAxisEuler	(	const Matrix3< double > &	m,
		int	axis0,
		int	axis1
	)

◆ rotationMatrixToTwoAxisEuler() [2/3]

template Vector2< float > momentum::rotationMatrixToTwoAxisEuler	(	const Matrix3< float > &	m,
		int	axis0,
		int	axis1
	)

◆ rotationMatrixToTwoAxisEuler() [3/3]

template<typename T >

Vector2< T > momentum::rotationMatrixToTwoAxisEuler	(	const Matrix3< T > &	m,
		int	axis0,
		int	axis1
	)

Fits a two-axis Euler rotation to a rotation matrix.

Finds the best-fit two-axis Euler angles (axis0 then axis1) that minimize the L2 distance to the target rotation matrix using Levenberg-Marquardt optimization.

Template Parameters

T	The scalar type.

Parameters

[in]	m	The target rotation matrix.
[in]	axis0	The index of the first rotation axis, one of {0, 1, 2}.
[in]	axis1	The index of the second rotation axis, one of {0, 1, 2}.

Returns: A 2D vector containing the fitted Euler angles [angle0, angle1].

Definition at line 808 of file utility.cpp.

References MT_CHECK, and rotationMatrixToOneAxisEuler().

◆ roundUpToAlignment()

constexpr std::size_t momentum::roundUpToAlignment	(	std::size_t	value,
		std::size_t	alignment
	)

inlineconstexpr

Definition at line 52 of file aligned.h.

References MT_THROW_IF_T.

Referenced by alignedAlloc().

◆ sampleFrames()

std::vector< size_t > momentum::sampleFrames	(	momentum::Character &	character,
		const MatrixXf &	initialMotion,
		std::span< const std::vector< momentum::Marker > >	markerData,
		const ParameterSet &	parameters,
		const size_t	frameStride,
		const size_t	numSamples
	)

Sample representative frames from motion data to maximize parameter variance.

Uses a greedy algorithm to select frames that are maximally different from each other in parameter space, while filtering out frames with high marker tracking errors. This is useful for calibration where you want to solve on a diverse set of poses rather than all frames.

Parameters

character	The character model used for computing marker errors
initialMotion	Initial motion parameters matrix (parameters x frames)
markerData	Marker observations for each frame
parameters	Set of parameters to consider for variance calculation
frameStride	Only consider every frameStride-th frame as candidates
numSamples	Maximum number of frames to sample

Returns: Vector of frame indices representing the selected keyframes

Definition at line 51 of file marker_tracker.cpp.

References momentum::CharacterT< T >::locators, momentum::CharacterT< T >::parameterTransform, momentum::SkeletonStateT< T >::set(), and momentum::CharacterT< T >::skeleton.

Referenced by calibrateLocators(), and calibrateModel().

◆ saveBlendShape() [1/2]

void momentum::saveBlendShape	(	const filesystem::path &	filename,
		const BlendShape &	blendShape
	)

Saves a blend shape to a file.

Parameters

filename	Output file path for the blend shape data
blendShape	BlendShape object to save

Definition at line 120 of file blend_shape_io.cpp.

References saveBlendShape().

Referenced by saveBlendShape().

◆ saveBlendShape() [2/2]

void momentum::saveBlendShape	(	std::ostream &	os,
		const BlendShape &	blendShape
	)

Saves a blend shape to a stream.

Parameters

os	Output stream to write blend shape data
blendShape	BlendShape object to save

Definition at line 128 of file blend_shape_io.cpp.

References momentum::BlendShape::getBaseShape(), momentum::BlendShapeBase::getShapeVectors(), and MT_CHECK.

◆ saveCharacter() [1/2]

void momentum::saveCharacter	(	const filesystem::path &	filename,
		const Character &	character,
		float	fps,
		std::span< const SkeletonState >	skeletonStates,
		std::span< const std::vector< Marker > >	markerSequence = `{}`,
		const FileSaveOptions &	options = `FileSaveOptions()`
	)

High level function to save a character with motion in skeleton states and markers to any supported format.

The format is determined by the file extension (.fbx, .glb, .gltf). This is a unified interface that automatically selects between FBX and GLTF based on extension.

Parameters

[in]	filename	The path where the character file will be saved.
[in]	character	The Character object to save.
[in]	fps	Frame rate for the animation.
[in]	skeletonStates	The motion represented in skeleton states (ie. JointStates).
[in]	markerSequence	Optional marker sequence data to save with the character.
[in]	options	Optional file save options for controlling output (default: FileSaveOptions{}).

Definition at line 176 of file character_io.cpp.

References Fbx, Gltf, MT_THROW, MT_THROW_IF, saveFbxWithSkeletonStates(), saveGltfCharacter(), and Unknown.

◆ saveCharacter() [2/2]

void momentum::saveCharacter	(	const filesystem::path &	filename,
		const Character &	character,
		float	fps = `120.f`,
		const MatrixXf &	motion = `MatrixXf()`,
		std::span< const std::vector< Marker > >	markerSequence = `{}`,
		const FileSaveOptions &	options = `FileSaveOptions()`
	)

High level function to save a character with motion and markers to any supported format.

The format is determined by the file extension (.fbx, .glb, .gltf). This is a unified interface that automatically selects between FBX and GLTF based on extension.

Parameters

[in]	filename	The path where the character file will be saved.
[in]	character	The Character object to save.
[in]	fps	Frame rate for the animation (default: 120.0f).
[in]	motion	The motion represented in model parameters (numModelParams, numFrames).
[in]	markerSequence	Optional marker sequence data to save with the character.
[in]	options	Optional file save options for controlling output (default: FileSaveOptions{}).

Definition at line 143 of file character_io.cpp.

References Fbx, Gltf, MT_THROW, MT_THROW_IF, momentum::ParameterTransformT< T >::name, momentum::CharacterT< T >::parameterTransform, saveFbx(), saveGltfCharacter(), and Unknown.

◆ saveCharacterToBytes()

std::vector< std::byte > momentum::saveCharacterToBytes	(	const Character &	character,
		float	fps,
		const MotionParameters &	motion,
		const IdentityParameters &	offsets,
		std::span< const std::vector< Marker > >	markerSequence,
		const FileSaveOptions &	options
	)

Definition at line 1346 of file gltf_io.cpp.

References makeCharacterDocument().

◆ saveCharacterToLegacyJson()

void momentum::saveCharacterToLegacyJson	(	const Character &	character,
		const std::string &	jsonPath
	)

Saves a Character to legacy JSON format.

This function converts a momentum::Character back to the legacy JSON format for compatibility with existing tools and workflows.

Parameters

[in]	character	The Character to save
[in]	jsonPath	Path where to save the legacy JSON file

Exceptions

std::runtime_error if the file cannot be written

Definition at line 566 of file legacy_json_io.cpp.

References characterToLegacyJson(), and MT_THROW_IF.

◆ saveFbx()

void momentum::saveFbx	(	const filesystem::path &	filename,
		const Character &	character,
		const MatrixXf &	poses = `MatrixXf()`,
		const VectorXf &	identity = `VectorXf()`,
		double	framerate = `120.0`,
		std::span< const std::vector< Marker > >	markerSequence = `{}`,
		const FileSaveOptions &	options = `FileSaveOptions()`
	)

Save a character with animation to an FBX file.

Parameters

filename	Path to the output FBX file
character	The character to save
poses	Model parameters for each frame (empty for bind pose only)
identity	Identity pose parameters (empty to use bind pose)
framerate	Animation framerate in frames per second
markerSequence	Optional marker sequence data to save with the character
options	Optional file save options for controlling output (default: FileSaveOptions{})

Definition at line 896 of file fbx_io.cpp.

References MT_THROW.

Referenced by saveCharacter(), and saveMotion().

◆ saveFbxModel()

void momentum::saveFbxModel	(	const filesystem::path &	filename,
		const Character &	character,
		const FileSaveOptions &	options = `FileSaveOptions()`
	)

Save a character model (skeleton and mesh) without animation.

Parameters

filename	Path to the output FBX file
character	The character to save
options	Optional file save options for controlling output (default: FileSaveOptions{})

Definition at line 930 of file fbx_io.cpp.

References MT_THROW.

◆ saveFbxWithJointParams()

void momentum::saveFbxWithJointParams	(	const filesystem::path &	filename,
		const Character &	character,
		const MatrixXf &	jointParams = `MatrixXf()`,
		double	framerate = `120.0`,
		std::span< const std::vector< Marker > >	markerSequence = `{}`,
		const FileSaveOptions &	options = `FileSaveOptions()`
	)

Save a character with animation using joint parameters directly.

Parameters

filename	Path to the output FBX file
character	The character to save
jointParams	Joint parameters for each frame (empty for bind pose only)
framerate	Animation framerate in frames per second
markerSequence	Optional marker sequence data to save with the character
options	Optional file save options for controlling output (default: FileSaveOptions{})

Definition at line 908 of file fbx_io.cpp.

References MT_THROW.

◆ saveFbxWithSkeletonStates()

void momentum::saveFbxWithSkeletonStates	(	const filesystem::path &	filename,
		const Character &	character,
		std::span< const SkeletonState >	skeletonStates,
		double	framerate = `120.0`,
		std::span< const std::vector< Marker > >	markerSequence = `{}`,
		const FileSaveOptions &	options = `FileSaveOptions()`
	)

Save a character with animation using skeleton states directly.

Parameters

filename	Path to the output FBX file
character	The character to save
skeletonStates	SkeletonState for each frame (empty for bind pose only)
framerate	Animation framerate in frames per second
markerSequence	Optional marker sequence data to save with the character
options	Optional file save options for controlling output (default: FileSaveOptions{})

Definition at line 919 of file fbx_io.cpp.

References MT_THROW.

Referenced by saveCharacter().

◆ saveGltfCharacter() [1/2]

void momentum::saveGltfCharacter	(	const filesystem::path &	filename,
		const Character &	character,
		float	fps,
		std::span< const SkeletonState >	skeletonStates,
		std::span< const std::vector< Marker > >	markerSequence = `{}`,
		const FileSaveOptions &	options = `FileSaveOptions()`
	)

Saves character skeleton states to a glb file.

Parameters

[in]	skeletonStates	The skeleton states for each frame of the motion sequence (numFrames, numJoints, 8)
[in]	options	Optional file save options for controlling output (default: FileSaveOptions{}).

Definition at line 1332 of file gltf_io.cpp.

References makeCharacterDocument(), and momentum::GltfBuilder::save().

◆ saveGltfCharacter() [2/2]

void momentum::saveGltfCharacter	(	const filesystem::path &	filename,
		const Character &	character,
		float	fps = `120.0f`,
		const MotionParameters &	motion = `{}`,
		const IdentityParameters &	offsets = `{}`,
		std::span< const std::vector< Marker > >	markerSequence = `{}`,
		const FileSaveOptions &	options = `FileSaveOptions()`
	)

Saves character motion to a glb file.

Parameters

[in]	motion	The model parameters representing the motion of the character (numModelParams, numFrames)
[in]	offsets	Offset values per joint capturing the skeleton bone lengths using translation and scale offset (7*numJoints, 1)
[in]	options	Optional file save options for controlling output (default: FileSaveOptions{}).

Definition at line 1317 of file gltf_io.cpp.

References makeCharacterDocument(), and momentum::GltfBuilder::save().

Referenced by saveCharacter(), and saveCharacter().

◆ saveLocators()

void momentum::saveLocators	(	const filesystem::path &	filename,
		const LocatorList &	locators,
		const Skeleton &	skeleton,
		const LocatorSpace	space
	)

Definition at line 218 of file locator_io.cpp.

References Global, momentum::SkeletonT< T >::joints, kParametersPerJoint, Local, MT_CHECK, and skeleton.

◆ saveMmo() [1/3]

void momentum::saveMmo	(	const std::string &	filename,
		const MatrixXf &	poses,
		const VectorXf &	scale,
		const Character &	character,
		const MatrixXf &	additionalParameters = `MatrixXf()`,
		std::span< const std::string >	additionalParameterNames = `std::vector< std::string >()`
	)

Save motion data with optional additional parameters.

Parameters

filename	Output file path
poses	Motion poses matrix (parameters x frames)
scale	Joint scale parameters
character	Character definition for parameter mapping
additionalParameters	Extra parameters to store alongside poses
additionalParameterNames	Names for additional parameters

Definition at line 43 of file mmo_io.cpp.

References momentum::SkeletonT< T >::joints, kParametersPerJoint, MT_LOGW, momentum::ParameterTransformT< T >::name, momentum::ParameterTransformT< T >::numAllModelParameters(), momentum::CharacterT< T >::parameterTransform, saveMmo(), and momentum::CharacterT< T >::skeleton.

◆ saveMmo() [2/3]

void momentum::saveMmo	(	const std::string &	filename,
		const MatrixXf &	poses,
		const VectorXf &	scale,
		std::span< const std::string >	parameterNames,
		std::span< const std::string >	jointNames
	)

Save motion data with explicit parameter and joint names.

Parameters

filename	Output file path
poses	Motion poses matrix (parameters x frames)
scale	Joint scale parameters
parameterNames	Names of motion parameters
jointNames	Names of skeleton joints

Definition at line 113 of file mmo_io.cpp.

References kParametersPerJoint, and MT_LOGW.

◆ saveMmo() [3/3]

void momentum::saveMmo	(	const std::string &	filename,
		std::span< const VectorXf >	poses,
		const VectorXf &	scale,
		const Character &	character
	)

Save motion data using character parameter mapping.

Parameters

filename	Output file path
poses	Motion poses as span of vectors, each vector represents one frame
scale	Joint scale parameters
character	Character definition for parameter mapping

Definition at line 17 of file mmo_io.cpp.

References MT_LOGW, momentum::ParameterTransformT< T >::numAllModelParameters(), momentum::CharacterT< T >::parameterTransform, and saveMmo().

Referenced by saveMmo(), and saveMmo().

◆ saveMotion()

void momentum::saveMotion	(	const std::string &	outFile,
		const momentum::Character &	character,
		const momentum::ModelParameters &	identity,
		Eigen::MatrixXf &	finalMotion,
		std::span< const std::vector< momentum::Marker > >	markerData,
		double	fps,
		bool	saveMarkerMesh = `true`
	)

Save the given character and motion to a GLB or FBX file.

Parameters

[in]	outFile	The GLB/FBX file to save to
[in]	character	The GLB/FBX file to save to
[in]	identity	The identity parameters used for the character
[in]	finalMotion	The motion save to the file. (Note: this may be modified to remove scaling parameters if saveScaleToMotion is false)
[in]	markerData	Marker data to save to the file
[in]	fps	Framerate of the motion
[in]	saveMarkerMesh	(optional) Whether to save a visible cube mesh for the markers
[in]	saveScaleToMotion	(optional) Whether to save the scale parameters to the motion or identity parameter vectors (saving to motion is preferred)

Definition at line 189 of file app_utils.cpp.

References momentum::GltfBuilder::addMotion(), momentum::ParameterTransformT< T >::apply(), extractParameters(), momentum::SkeletonT< T >::getJointNames(), momentum::ParameterTransformT< T >::getScalingParameters(), momentum::ParameterTransformT< T >::name, momentum::GltfBuilder::None, momentum::CharacterT< T >::parameterTransform, removeIdentity(), saveFbx(), momentum::CharacterT< T >::skeleton, momentum::GltfBuilder::UnitCube, and momentum::EigenStrongType< Derived, EigenType >::v.

Referenced by processMarkerFile().

◆ saveMppca()

void momentum::saveMppca	(	const Mppca &	mppca,
		const std::string &	name
	)

Definition at line 84 of file mppca_io.cpp.

References MT_CHECK.

◆ saveUsd()

void momentum::saveUsd	(	const filesystem::path &	filename,
		const Character &	character
	)

Save a character to a USD file.

Parameters

[in]	filename	The path to save the USD file.
[in]	character	The Character object to save.

Definition at line 510 of file usd_io.cpp.

References momentum::SkeletonT< T >::joints, momentum::CharacterT< T >::mesh, MT_THROW_IF, momentum::CharacterT< T >::skeleton, skeleton, and momentum::CharacterT< T >::skinWeights.

◆ scaleCharacter()

Character momentum::scaleCharacter	(	const Character &	character,
		float	scale
	)

Scales the character (mesh and skeleton) by the desired amount.

Note that this should primarily be used when transforming the character into different units. If you simply want to apply an identity-specific scale to the character, you should use the 'scale_global' parameter in the ParameterTransform class.

Parameters

[in]	character	Character to be scaled
[in]	scale	Scale factor to apply

Returns: A new Character object that has been scaled

inline

Definition at line 248 of file accessor_utils.h.

◆ setLogLevel() [1/2]

void momentum::setLogLevel ( const std::string & levelStr )

Definition at line 89 of file log.cpp.

References setLogLevel().

◆ setLogLevel() [2/2]

void momentum::setLogLevel ( LogLevel level )

Definition at line 80 of file log.cpp.

References MT_LOGW.

Referenced by setLogLevel().

◆ skeletonStateToJointParameters() [1/6]

template JointParametersT< double > momentum::skeletonStateToJointParameters	(	const SkeletonStateT< double > &	state,
		const Skeleton &	skeleton
	)

◆ skeletonStateToJointParameters() [2/6]

template JointParametersT< float > momentum::skeletonStateToJointParameters	(	const SkeletonStateT< float > &	state,
		const Skeleton &	skeleton
	)

◆ skeletonStateToJointParameters() [3/6]

template<typename T >

JointParametersT< T > momentum::skeletonStateToJointParameters	(	const SkeletonStateT< T > &	state,
		const Skeleton &	skeleton
	)

Invert the skeleton state (global transforms in world space) back to joint parameters (Euler angles in local space).

Note that this conversion is not unique due to the non-uniqueness of Euler angle conversion.

Definition at line 250 of file skeleton_state.cpp.

References momentum::SkeletonT< T >::joints, kInvalidIndex, kParametersPerJoint, skeleton, momentum::EigenStrongType< Derived, EigenType >::v, and momentum::EigenStrongType< JointParametersT, ::Eigen::VectorX< T > >::Zero().

◆ skeletonStateToJointParameters() [4/6]

template JointParametersT< double > momentum::skeletonStateToJointParameters	(	const TransformListT< double > &	state,
		const Skeleton &	skeleton
	)

◆ skeletonStateToJointParameters() [5/6]

template JointParametersT< float > momentum::skeletonStateToJointParameters	(	const TransformListT< float > &	state,
		const Skeleton &	skeleton
	)

◆ skeletonStateToJointParameters() [6/6]

template<typename T >

JointParametersT< T > momentum::skeletonStateToJointParameters	(	const TransformListT< T > &	state,
		const Skeleton &	skeleton
	)

Definition at line 272 of file skeleton_state.cpp.

References momentum::SkeletonT< T >::joints, kInvalidIndex, kParametersPerJoint, skeleton, momentum::EigenStrongType< Derived, EigenType >::v, and momentum::EigenStrongType< JointParametersT, ::Eigen::VectorX< T > >::Zero().

◆ skeletonStateToJointParametersRespectingActiveParameters() [1/6]

template JointParametersT< double > momentum::skeletonStateToJointParametersRespectingActiveParameters	(	const SkeletonStateT< double > &	state,
		const Skeleton &	skeleton,
		const VectorX< bool > &	activeJointParams
	)

◆ skeletonStateToJointParametersRespectingActiveParameters() [2/6]

template JointParametersT< float > momentum::skeletonStateToJointParametersRespectingActiveParameters	(	const SkeletonStateT< float > &	state,
		const Skeleton &	skeleton,
		const VectorX< bool > &	activeJointParams
	)

◆ skeletonStateToJointParametersRespectingActiveParameters() [3/6]

template<typename T >

JointParametersT< T > momentum::skeletonStateToJointParametersRespectingActiveParameters	(	const SkeletonStateT< T > &	state,
		const Skeleton &	skeleton,
		const VectorX< bool > &	activeJointParams
	)

Converts skeleton state back to joint parameters, respecting active joint parameter constraints.

This function addresses the limitation of the original skeletonStateToJointParameters which always uses 3-axis Euler rotations. Many joints only support 1-axis or 2-axis rotations, so this function uses the provided activeJointParams to determine how many rotation axes are active for each joint and applies the appropriate conversion method:

0 active rotation axes: Sets all rotation parameters to zero
1 active rotation axis: Uses rotationMatrixToOneAxisEuler
2 active rotation axes: Uses rotationMatrixToTwoAxisEuler
3 active rotation axes: Uses the standard 3-axis Euler conversion

Template Parameters

T	The scalar type (float or double)

Parameters

[in]	state	The skeleton state to convert
[in]	skeleton	The skeleton defining joint hierarchy and properties
[in]	activeJointParams	Boolean array indicating which joint parameters are active. Size should be skeleton.joints.size() * kParametersPerJoint

Returns: Joint parameters with rotations respecting the active parameter constraints

Definition at line 371 of file skeleton_state.cpp.

References momentum::SkeletonT< T >::joints, kInvalidIndex, kParametersPerJoint, MT_CHECK, skeleton, momentum::EigenStrongType< Derived, EigenType >::v, and momentum::EigenStrongType< JointParametersT, ::Eigen::VectorX< T > >::Zero().

◆ skeletonStateToJointParametersRespectingActiveParameters() [4/6]

template JointParametersT< double > momentum::skeletonStateToJointParametersRespectingActiveParameters	(	const TransformListT< double > &	state,
		const Skeleton &	skeleton,
		const VectorX< bool > &	activeJointParams
	)

◆ skeletonStateToJointParametersRespectingActiveParameters() [5/6]

template JointParametersT< float > momentum::skeletonStateToJointParametersRespectingActiveParameters	(	const TransformListT< float > &	state,
		const Skeleton &	skeleton,
		const VectorX< bool > &	activeJointParams
	)

◆ skeletonStateToJointParametersRespectingActiveParameters() [6/6]

template<typename T >

JointParametersT< T > momentum::skeletonStateToJointParametersRespectingActiveParameters	(	const TransformListT< T > &	state,
		const Skeleton &	skeleton,
		const VectorX< bool > &	activeJointParams
	)

Converts transform list back to joint parameters, respecting active joint parameter constraints.

This function addresses the limitation of the original skeletonStateToJointParameters which always uses 3-axis Euler rotations. Many joints only support 1-axis or 2-axis rotations, so this function uses the provided activeJointParams to determine how many rotation axes are active for each joint and applies the appropriate conversion method:

0 active rotation axes: Sets all rotation parameters to zero
1 active rotation axis: Uses rotationMatrixToOneAxisEuler
2 active rotation axes: Uses rotationMatrixToTwoAxisEuler
3 active rotation axes: Uses the standard 3-axis Euler conversion

Template Parameters

T	The scalar type (float or double)

Parameters

[in]	state	The transform list to convert
[in]	skeleton	The skeleton defining joint hierarchy and properties
[in]	activeJointParams	Boolean array indicating which joint parameters are active. Size should be skeleton.joints.size() * kParametersPerJoint

Returns: Joint parameters with rotations respecting the active parameter constraints

Definition at line 404 of file skeleton_state.cpp.

References momentum::SkeletonT< T >::joints, kInvalidIndex, kParametersPerJoint, MT_CHECK, skeleton, momentum::EigenStrongType< Derived, EigenType >::v, and momentum::EigenStrongType< JointParametersT, ::Eigen::VectorX< T > >::Zero().

◆ skinWithBlendShapes() [1/6]

template void momentum::skinWithBlendShapes	(	const Character &	character,
		const SkeletonStateT< double > &	state,
		const BlendWeightsT< double > &	modelParams,
		MeshT< double > &	outputMesh
	)

References skinWithBlendShapes().

◆ skinWithBlendShapes() [2/6]

template void momentum::skinWithBlendShapes	(	const Character &	character,
		const SkeletonStateT< double > &	state,
		const ModelParametersT< double > &	modelParams,
		MeshT< double > &	outputMesh
	)

References skinWithBlendShapes().

◆ skinWithBlendShapes() [3/6]

template void momentum::skinWithBlendShapes	(	const Character &	character,
		const SkeletonStateT< float > &	state,
		const BlendWeightsT< float > &	modelParams,
		MeshT< float > &	outputMesh
	)

References skinWithBlendShapes().

◆ skinWithBlendShapes() [4/6]

template void momentum::skinWithBlendShapes	(	const Character &	character,
		const SkeletonStateT< float > &	state,
		const ModelParametersT< float > &	modelParams,
		MeshT< float > &	outputMesh
	)

References skinWithBlendShapes().

◆ skinWithBlendShapes() [5/6]

template<typename T >

void momentum::skinWithBlendShapes	(	const Character &	character,
		const SkeletonStateT< T > &	state,
		const BlendWeightsT< T > &	blendWeights,
		MeshT< T > &	outputMesh
	)

Applies blend shape deformations and skeletal transformations to a mesh.

Computes the final vertex positions by applying blend shape offsets to the base mesh, then transforming the resulting vertices using linear blend skinning based on the skeleton state. Use this version when you already have pre-calculated blend weights.

Parameters

character	Character containing mesh, blend shapes, and skinning data
state	Current pose of the skeleton
blendWeights	Weights for each blend shape
outputMesh	Mesh to store the resulting deformed vertices

Definition at line 60 of file blend_shape_skinning.cpp.

References momentum::CharacterT< T >::blendShape, momentum::CharacterT< T >::inverseBindPose, momentum::CharacterT< T >::mesh, MT_CHECK, and momentum::CharacterT< T >::skinWeights.

◆ skinWithBlendShapes() [6/6]

template<typename T >

void momentum::skinWithBlendShapes	(	const Character &	character,
		const SkeletonStateT< T > &	state,
		const ModelParametersT< T > &	modelParams,
		MeshT< T > &	outputMesh
	)

Applies blend shape deformations and skeletal transformations to a mesh.

Overload that extracts blend shape weights from model parameters before skinning. Use this version when working with high-level character animation where you have model parameters rather than direct blend weights.

Parameters

character	Character containing mesh, blend shapes, and skinning data
state	Current pose of the skeleton
modelParams	Model parameters containing blend shape weights
outputMesh	Mesh to store the resulting deformed vertices

Definition at line 50 of file blend_shape_skinning.cpp.

References extractBlendWeights(), momentum::CharacterT< T >::parameterTransform, and skinWithBlendShapes().

Referenced by momentum::CharacterStateT< T >::set(), skinWithBlendShapes(), skinWithBlendShapes(), skinWithBlendShapes(), skinWithBlendShapes(), and skinWithBlendShapes().

◆ slerp() [1/3]

template TransformT< double > momentum::slerp	(	const TransformT< double > &	,
		const TransformT< double > &	,
		double
	)

◆ slerp() [2/3]

template TransformT< float > momentum::slerp	(	const TransformT< float > &	,
		const TransformT< float > &	,
		float
	)

◆ slerp() [3/3]

template<typename T >

TransformT< T > momentum::slerp	(	const TransformT< T > &	t1,
		const TransformT< T > &	t2,
		T	weight
	)

Spherical linear interpolation between two transforms.

Definition at line 144 of file transform.cpp.

◆ sqr() [1/2]

template<class T >

T momentum::sqr ( const T & x )

inline

Computes the square of a value.

Convenience function for x * x

Definition at line 47 of file utility.h.

◆ sqr() [2/2]

float momentum::sqr ( float val )

Definition at line 70 of file fully_differentiable_body_ik.cpp.

◆ subsetParameterTransform() [1/3]

template std::tuple< ParameterTransformT< double >, ParameterLimits > momentum::subsetParameterTransform	(	const ParameterTransformT< double > &	paramTransform,
		const ParameterLimits &	parameterLimits,
		const ParameterSet &	paramSet
	)

◆ subsetParameterTransform() [2/3]

template std::tuple< ParameterTransformT< float >, ParameterLimits > momentum::subsetParameterTransform	(	const ParameterTransformT< float > &	paramTransform,
		const ParameterLimits &	parameterLimits,
		const ParameterSet &	paramSet
	)

◆ subsetParameterTransform() [3/3]

template<typename T >

std::tuple< ParameterTransformT< T >, ParameterLimits > momentum::subsetParameterTransform	(	const ParameterTransformT< T > &	paramTransformOld,
		const ParameterLimits &	paramLimitsOld,
		const ParameterSet &	paramSet
	)

Return a parameter mapping that only includes the listed parameters.

Definition at line 294 of file parameter_transform.cpp.

References Ellipsoid, HalfPlane, kInvalidIndex, LimitTypeCount, Linear, LinearJoint, MinMax, MinMaxJoint, MinMaxJointPassive, and momentum::PoseConstraint::parameterIdValue.

Referenced by addBlendShapeParameters(), addFaceExpressionParameters(), addSkinnedLocatorParameters(), momentum::CharacterT< T >::bake(), momentum::CharacterT< T >::bakeBlendShape(), momentum::ParameterTransformT< T >::simplify(), and momentum::CharacterT< T >::simplifyParameterTransform().

◆ subsetVecToFullVec()

template<typename T >

Eigen::VectorX< T > momentum::subsetVecToFullVec	(	Eigen::Ref< const Eigen::VectorX< T > >	subsetVec,
		const std::vector< Eigen::Index > &	subsetIndexToFullParamIndex,
		Eigen::Index	fullVecSize
	)

Definition at line 59 of file fully_differentiable_body_ik.cpp.

◆ times_parameterTransform_times_v()

template<typename T , typename T2 >

T momentum::times_parameterTransform_times_v	(	const T &	value,
		const size_t	jointParamIdx,
		const ParameterTransform &	parameterTransform,
		Eigen::Ref< const Eigen::VectorX< T2 > >	v
	)

Definition at line 57 of file ceres_utility.h.

References parameterTransform, and momentum::ParameterTransformT< T >::transform.

Referenced by momentum::FullyDifferentiableProjectionErrorFunctionT< T >::constraintGradient_dot().

◆ toCm()

template<typename T = float>

constexpr T momentum::toCm ( T x = T(1) )

constexprnoexcept

Converts the given length x (in meters) to centimeters.

If called without an argument, it returns the conversion factor from meters to centimeters.

Definition at line 77 of file constants.h.

Referenced by toMomentumVec3f(), and toMomentumVec3f().

◆ toColumnMajor()

template<typename T >

Eigen::SparseMatrix< T > momentum::toColumnMajor ( const SparseRowMatrix< T > & mat )

Definition at line 16 of file inverse_parameter_transform.cpp.

◆ toDeg()

template<typename T = float>

constexpr T momentum::toDeg ( T x = T(1) )

constexprnoexcept

Converts the given angle x (in radians) to degrees.

If called without an argument, it returns the conversion factor from radians to degrees.

Definition at line 59 of file constants.h.

Referenced by writeParameterLimits().

◆ toJson()

template<typename Derived >

void momentum::toJson	(	const Eigen::MatrixBase< Derived > &	mat,
		nlohmann::json &	j
	)

Definition at line 25 of file json_utils.h.

Referenced by parameterLimitsToJson().

◆ tokenize() [1/2]

std::vector< std::string > momentum::tokenize	(	const std::string &	inputString,
		const std::string &	delimiters = `" \t\r\n"`,
		bool	trim = `true`
	)

Tokenize a string using the specified delimiters.

Parameters

inputString	The string to tokenize.
delimiters	The string containing delimiter characters.
trim	Whether to trim spaces around the tokens (default: true).

Returns: A vector of tokenized strings.

Definition at line 42 of file string.cpp.

References trim().

Referenced by loadLocatorsFromBuffer(), loadTrc(), parseParameterSets(), parseParameterTransform(), and parsePoseConstraints().

◆ tokenize() [2/2]

std::vector< std::string_view > momentum::tokenize	(	std::string_view	inputString,
		std::string_view	delimiters = `" \t\r\n"`,
		bool	trim = `true`
	)

Tokenize a string_view using the specified delimiters.

Parameters

inputString	The string_view to tokenize.
delimiters	The string_view containing delimiter characters.
trim	Whether to trim spaces around the tokens (default: true).

Returns: A vector of tokenized string_views.

Definition at line 70 of file string.cpp.

References trim().

◆ toM()

template<typename T = float>

constexpr T momentum::toM ( T x = T(1) )

constexprnoexcept

Converts the given length x (in centimeters) to meters.

If called without an argument, it returns the conversion factor from centimeters to meters.

Definition at line 68 of file constants.h.

Referenced by fromMomentumVec3f(), fromMomentumVec3f(), fromMomentumVec3f(), parameterLimitsFromJson(), and parameterLimitsToJson().

◆ toMomentumQuaternionf()

Quaternionf momentum::toMomentumQuaternionf ( const std::array< float, 4 > & gltfQuat )

inlinenoexcept

Definition at line 26 of file coordinate_utils.h.

◆ toMomentumVec3f() [1/2]

Vector3f momentum::toMomentumVec3f ( const std::array< float, 3 > & vec )

inlinenoexcept

Definition at line 18 of file coordinate_utils.h.

References toCm().

Referenced by loadMarkerSequence().

◆ toMomentumVec3f() [2/2]

void momentum::toMomentumVec3f ( std::vector< Vector3f > & vec )

inline

Definition at line 36 of file coordinate_utils.h.

References toCm().

◆ toMomentumVector3() [1/6]

template Vector3< double > momentum::toMomentumVector3	(	const Vector3< double > &	vec,
		UpVector	up,
		const std::string &	unitStr
	)

◆ toMomentumVector3() [2/6]

template Vector3< double > momentum::toMomentumVector3	(	const Vector3< double > &	vec,
		UpVector	up,
		Unit	unit
	)

◆ toMomentumVector3() [3/6]

template Vector3< float > momentum::toMomentumVector3	(	const Vector3< float > &	vec,
		UpVector	up,
		const std::string &	unitStr
	)

◆ toMomentumVector3() [4/6]

template Vector3< float > momentum::toMomentumVector3	(	const Vector3< float > &	vec,
		UpVector	up,
		Unit	unit
	)

◆ toMomentumVector3() [5/6]

template<typename T >

Vector3< T > momentum::toMomentumVector3	(	const Vector3< T > &	vec,
		UpVector	up,
		const std::string &	unitStr
	)

This function converts a 3D vector in the mocap marker coordinate system to the Momentum coordinate system, using a string to specify the unit.

The mocap marker coordinate system uses a spatial index with a specified up-axis (default Z), right-handedness, and units specified in the 'unitStr' parameter (e.g., "m", "cm", "mm"). The Momentum coordinate system uses a spatial index with Y as the up-axis, right-handedness, and units in centimeters.

Template Parameters

T	The numeric type of the input and output 3D vectors.

Parameters

[in]	vec	The 3D vector in the mocap marker coordinate system to be converted.
[in]	up	(Optional) The up-axis convention of the input marker coordinate system (default: UpVector::Z).
[in]	unitStr	The string representation of the units of measurement used in the input marker coordinate system.

Returns: A 3D vector in the Momentum coordinate system.

Note: This conversion has only been tested for TRC and C3D formats.

Definition at line 101 of file conversions.cpp.

References toMomentumVector3().

◆ toMomentumVector3() [6/6]

template<typename T >

Vector3< T > momentum::toMomentumVector3	(	const Vector3< T > &	vec,
		UpVector	up = `UpVector::Z`,
		Unit	unit = `Unit::MM`
	)

This function converts a 3D vector in the mocap marker coordinate system to the Momentum coordinate system.

The mocap marker coordinate system uses a spatial index with a specified up-axis (default Z), right-handedness, and units specified in the 'unit' parameter (default millimeters). The Momentum coordinate system uses a spatial index with Y as the up-axis, right-handedness, and units in centimeters.

Template Parameters

T	The numeric type of the input and output 3D vectors.

Parameters

[in]	vec	The 3D vector in the mocap marker coordinate system to be converted.
[in]	up	(Optional) The up-axis convention of the input marker coordinate system (default: UpVector::Z).
[in]	unit	(Optional) The units of measurement used in the input marker coordinate system (default: Unit::MM).

Returns: A 3D vector in the Momentum coordinate system.

Note: This conversion has only been tested for TRC and C3D formats.

Definition at line 49 of file conversions.cpp.

References CM, DM, M, MM, MT_LOGE, toString(), Unknown, X, Y, YNeg, and Z.

Referenced by loadC3d(), loadTrc(), and toMomentumVector3().

◆ toRad()

template<typename T = float>

constexpr T momentum::toRad ( T x = T(1) )

constexprnoexcept

Converts the given angle x (in degrees) to radians.

If called without an argument, it returns the conversion factor from degrees to radians.

Definition at line 49 of file constants.h.

◆ toString() [1/2]

std::string_view momentum::toString ( const LimitType type )

Definition at line 15 of file parameter_limits.cpp.

References Ellipsoid, HalfPlane, LimitTypeCount, Linear, LinearJoint, MinMax, MinMaxJoint, and MinMaxJointPassive.

Referenced by parameterLimitsToJson(), momentum::PointTriangleVertexErrorFunctionT< T >::PointTriangleVertexErrorFunctionT(), toMomentumVector3(), and momentum::VertexErrorFunctionT< T >::VertexErrorFunctionT().

◆ toString() [2/2]

std::string_view momentum::toString ( VertexConstraintType type )

Definition at line 30 of file vertex_error_function.cpp.

◆ trackPosesForFrames() [1/2]

Eigen::MatrixXf momentum::trackPosesForFrames	(	const std::span< const std::vector< Marker > >	markerData,
		const Character &	character,
		const MatrixXf &	initialMotion,
		const TrackingConfig &	config,
		const std::vector< size_t > &	frameIndices,
		bool	isContinuous
	)

Track poses independently for specific frame indices with fixed character identity.

Similar to trackPosesPerframe, but only solves for the specified frame indices rather than processing frames with a stride. This is particularly useful during calibration when you want to solve poses only for carefully selected keyframes that have been sampled for maximum parameter variance.

Parameters

markerData	Marker observations for each frame
character	The character model with fixed identity parameters
initialMotion	Initial parameter values (parameters x frames)
config	Tracking configuration settings
frameIndices	Vector of specific frame indices to solve
isContinuous	Whether to use temporal coherence between frames

Returns: Solved motion parameters matrix (parameters x frames) with poses for selected frames

Definition at line 516 of file marker_tracker.cpp.

References momentum::CharacterT< T >::collision, createConstraintData(), createFloorConstraints< float >(), createSkinnedConstraintData(), isGlobalTransformZero(), momentum::PlaneErrorFunctionT< T >::kLegacyWeight, momentum::PositionErrorFunctionT< T >::kLegacyWeight, momentum::CharacterT< T >::locators, momentum::SolverOptions::maxIterations, MT_CHECK, MT_LOGI, MT_LOGI_IF, MT_LOGW, momentum::ParameterTransformT< T >::numAllModelParameters(), momentum::CharacterT< T >::parameterTransform, and momentum::CharacterT< T >::skinnedLocators.

Referenced by calibrateLocators(), calibrateModel(), and trackPosesPerframe().

◆ trackPosesForFrames() [2/2]

Eigen::MatrixXf momentum::trackPosesForFrames	(	std::span< const std::vector< momentum::Marker > >	markerData,
		const momentum::Character &	character,
		const Eigen::MatrixXf &	initialMotion,
		const TrackingConfig &	config,
		const std::vector< size_t > &	frameIndices,
		bool	isContinuous = `false`
	)

Track poses for given frames.

Parameters

[in]	markerData	Input marker data.
[in]	character	Character definition.
[in]	globalParams	Calibrated identity info; could be repurposed to pass in an initial pose too.
[in]	config	Solving options.
[in]	frameIndices	Frame indices of the frames to be solved.
[in]	isContinuous	Whether to use temporal coherence between frames.

Returns: The solved motion. It has the same length as markerData. It repeats the same solved pose within a frame stride.

◆ trackPosesPerframe() [1/2]

Eigen::MatrixXf momentum::trackPosesPerframe	(	const std::span< const std::vector< Marker > >	markerData,
		const Character &	character,
		const ModelParameters &	globalParams,
		const TrackingConfig &	config,
		const size_t	frameStride
	)

Track poses independently per frame with fixed character identity.

This is the main production tracking function used after character calibration. It solves each frame independently using a per-frame optimizer, which makes it robust to tracking failures. The character identity (scaling, locators, blend shapes) is fixed from calibration and only pose parameters are solved.

Parameters

markerData	Marker observations for each frame
character	The character model with calibrated identity parameters
globalParams	Fixed global parameters (scaling, locators, etc.) from calibration
config	Tracking configuration settings
frameStride	Process every frameStride-th frame (1 = all frames)

Returns: Solved motion parameters matrix (parameters x frames) with fixed identity

Definition at line 474 of file marker_tracker.cpp.

References MT_CHECK, and trackPosesForFrames().

Referenced by calibrateLocators(), calibrateModel(), and processMarkers().

◆ trackPosesPerframe() [2/2]

Eigen::MatrixXf momentum::trackPosesPerframe	(	std::span< const std::vector< momentum::Marker > >	markerData,
		const momentum::Character &	character,
		const momentum::ModelParameters &	globalParams,
		const TrackingConfig &	config,
		size_t	frameStride = `1`
	)

Track poses per-frame given a calibrated character.

Parameters

[in]	markerData	Input marker data.
[in]	character	Character definition.
[in]	globalParams	Calibrated identity info; could be repurposed to pass in an initial pose too.
[in]	config	Solving options.
[in]	frameStride	Frame stride to select solver frames (ie. uniform sample).

Returns: The solved motion. It has the same length as markerData. It repeats the same solved pose within a frame stride.

◆ trackSequence() [1/4]

Eigen::MatrixXf momentum::trackSequence	(	const std::span< const std::vector< Marker > >	markerData,
		const Character &	character,
		const ParameterSet &	globalParams,
		const MatrixXf &	initialMotion,
		const TrackingConfig &	config,
		const std::vector< size_t > &	frames,
		float	regularizer,
		bool	enforceFloorInFirstFrame,
		const std::string &	firstFramePoseConstraintSet
	)

Track motion across multiple frames simultaneously for specific frame indices.

This is the same as the main trackSequence function above, but instead of using a frameStride to sample frames uniformly, it tracks motion only for the specified frame indices. This is particularly useful during calibration when you want to solve on carefully selected keyframes rather than uniformly sampled frames.

Parameters

markerData	Marker observations for each frame
character	The character model with skeleton, locators, and parameter transform
globalParams	Set of global parameters to solve (scaling, locators, etc.)
initialMotion	Initial parameter values (parameters x frames)
config	Tracking configuration settings
frames	Vector of specific frame indices to solve
regularizer	Weight for regularizing changes to global parameters
enforceFloorInFirstFrame	Force floor contact constraints in first frame
firstFramePoseConstraintSet	Name of pose constraint set for first frame

Returns: Solved motion parameters matrix (parameters x frames)

Definition at line 233 of file marker_tracker.cpp.

References momentum::CharacterT< T >::collision, createConstraintData(), createFloorConstraints< float >(), createSkinnedConstraintData(), createSkinnedLocatorMeshConstraints(), getPoseConstraintParameterLimits(), momentum::ParameterTransformT< T >::getPoseParameters(), kAllFrames, momentum::PlaneErrorFunctionT< T >::kLegacyWeight, momentum::PositionErrorFunctionT< T >::kLegacyWeight, momentum::CharacterT< T >::locators, momentum::SolverOptions::maxIterations, MT_CHECK, MT_LOGI_IF, momentum::ParameterTransformT< T >::numAllModelParameters(), momentum::CharacterT< T >::parameterTransform, momentum::ParameterTransformT< T >::poseConstraints, momentum::CharacterT< T >::skinnedLocators, and momentum::EigenStrongType< Derived, EigenType >::Zero().

◆ trackSequence() [2/4]

Eigen::MatrixXf momentum::trackSequence	(	const std::span< const std::vector< Marker > >	markerData,
		const Character &	character,
		const ParameterSet &	globalParams,
		const MatrixXf &	initialMotion,
		const TrackingConfig &	config,
		float	regularizer,
		const size_t	frameStride,
		bool	enforceFloorInFirstFrame,
		const std::string &	firstFramePoseConstraintSet
	)

Track motion across multiple frames simultaneously with temporal constraints.

This is the main global optimization function that solves for both pose parameters and global parameters (scaling, locators, blend shapes) across multiple frames simultaneously. It enforces temporal smoothness constraints and can handle calibration scenarios where identity parameters need to be solved.

Parameters

markerData	Marker observations for each frame
character	The character model with skeleton, locators, and parameter transform
globalParams	Set of global parameters to solve (scaling, locators, etc.)
initialMotion	Initial parameter values (parameters x frames)
config	Tracking configuration settings
regularizer	Weight for regularizing changes to global parameters
frameStride	Process every frameStride-th frame (1 = all frames)
enforceFloorInFirstFrame	Force floor contact constraints in first frame
firstFramePoseConstraintSet	Name of pose constraint set for first frame

Returns: Solved motion parameters matrix (parameters x frames)

Definition at line 187 of file marker_tracker.cpp.

References trackSequence().

Referenced by calibrateLocators(), calibrateModel(), refineMotion(), and trackSequence().

◆ trackSequence() [3/4]

Eigen::MatrixXf momentum::trackSequence	(	std::span< const std::vector< momentum::Marker > >	markerData,
		const momentum::Character &	character,
		const momentum::ParameterSet &	globalParams,
		const Eigen::MatrixXf &	initialMotion,
		const TrackingConfig &	config,
		const std::vector< size_t > &	frames,
		float	regularizer = `0.0`,
		bool	enforceFloorInFirstFrame = `false`,
		const std::string &	firstFramePoseConstraintSet = `""`
	)

Use multiple frames to solve for global parameters such as body proportions and/or marker offsets together with the motion.

Parameters

[in]	markerData	Marker data.
[in]	character	Character definition.
[in]	globalParams	Bitset to indicate global parameters to solve for; could be all zeros for post-process a motion.
[in]	initialMotion	Initial values of all parameters. It should be the same length as markerData, but only frames used in solving are used. Values in unused frames do not matter. Number of parameters should be the same as defined in character.
[in]	config	Solving options.
[in]	frames	List of frames to solve for.
[in]	enforceFloorInFirstFrame	Flag to enforce the floor contact constraints in first frame
[in]	firstFramePoseConstraintSet	Name of a pose constraint set to use for the first frame

Returns: The solved motion. It has the same length as markerData. It repeats the same solved pose within a frame stride.

◆ trackSequence() [4/4]

Eigen::MatrixXf momentum::trackSequence	(	std::span< const std::vector< momentum::Marker > >	markerData,
		const momentum::Character &	character,
		const momentum::ParameterSet &	globalParams,
		const Eigen::MatrixXf &	initialMotion,
		const TrackingConfig &	config,
		float	regularizer = `0.0`,
		size_t	frameStride = `1`,
		bool	enforceFloorInFirstFrame = `false`,
		const std::string &	firstFramePoseConstraintSet = `""`
	)

Use multiple frames to solve for global parameters such as body proportions and/or marker offsets together with the motion.

It can also be used to smooth out a motion with or without solving for global parameters, for example to fill gaps when there are missing markers.

Parameters

[in]	markerData	Marker data.
[in]	character	Character definition.
[in]	globalParams	Bitset to indicate global parameters to solve for; could be all zeros for post-process a motion.
[in]	initialMotion	Initial values of all parameters. It should be the same length as markerData, but only frames used in solving are used. Values in unused frames do not matter. Number of parameters should be the same as defined in character.
[in]	config	Solving options.
[in]	frameStride	Frame stride to select solver frames (ie. uniform sample).
[in]	enforceFloorInFirstFrame	Flag to enforce the floor contact constraints in first frame
[in]	firstFramePoseConstraintSet	Name of a pose constraint set to use for the first frame

Returns: The solved motion. It has the same length as markerData. It repeats the same solved pose within a frame stride.

◆ transformAtoB() [1/3]

template TransformT< double > momentum::transformAtoB	(	size_t	jointA,
		size_t	jointB,
		const Skeleton &	referenceSkeleton,
		const SkeletonStateT< double > &	skelState
	)

◆ transformAtoB() [2/3]

template TransformT< float > momentum::transformAtoB	(	size_t	jointA,
		size_t	jointB,
		const Skeleton &	referenceSkeleton,
		const SkeletonStateT< float > &	skelState
	)

◆ transformAtoB() [3/3]

template<typename T >

TransformT< T > momentum::transformAtoB	(	size_t	jointA,
		size_t	jointB,
		const Skeleton &	referenceSkeleton,
		const SkeletonStateT< T > &	skelState
	)

Computes the relative transform between two joints in a skeleton.

This transform maps points from joint A's local space to joint B's local space. It is computed by finding the common ancestor of both joints and combining the transforms along the path, which is more numerically stable than computing (T_B)^{-1} * T_A directly.

Parameters

jointA	Source joint index
jointB	Target joint index
referenceSkeleton	The skeleton structure defining joint hierarchy
skelState	Current state of the skeleton

Returns: Transform from joint A's local space to joint B's local space

Definition at line 188 of file skeleton_state.cpp.

References kInvalidIndex, and MT_CHECK.

◆ transformCharacter()

Character momentum::transformCharacter	(	const Character &	character,
		const Affine3f &	xform
	)

Transforms the character (mesh and skeleton) by the desired transformation matrix.

The transformation matrix should not have any scale or shear.

Note that this should primarily be used for transforming models between different coordinate spaces (e.g. y-up vs. z-up). If you want to move a character around the scene, you should preferably use the model parameters.

Parameters

[in]	character	Character to be transformed
[in]	xform	Transformation to apply

Returns: A new Character object that has been transformed

Definition at line 424 of file character_utility.cpp.

References momentum::CharacterT< T >::blendShape, momentum::CharacterT< T >::collision, momentum::CharacterT< T >::faceExpressionBlendShape, momentum::CharacterT< T >::inverseBindPose, momentum::CharacterT< T >::locators, momentum::CharacterT< T >::mesh, momentum::CharacterT< T >::name, momentum::CharacterT< T >::parameterLimits, momentum::CharacterT< T >::parameterTransform, momentum::CharacterT< T >::poseShapes, momentum::CharacterT< T >::skeleton, and momentum::CharacterT< T >::skinWeights.

◆ transformPose() [1/6]

template std::vector< ModelParametersT< double > > momentum::transformPose	(	const Character &	character,
		const std::vector< ModelParametersT< double > > &	modelParameters,
		const TransformT< double > &	transform
	)

◆ transformPose() [2/6]

template std::vector< ModelParametersT< float > > momentum::transformPose	(	const Character &	character,
		const std::vector< ModelParametersT< float > > &	modelParameters,
		const TransformT< float > &	transform
	)

◆ transformPose() [3/6]

template<typename T >

std::vector< ModelParametersT< T > > momentum::transformPose	(	const Character &	character,
		const std::vector< ModelParametersT< T > > &	modelParameters,
		const std::vector< TransformT< T > > &	transforms,
		bool	ensureContinuousOutput = `true`
	)

Function which computes a new set of model parameters such that the character pose is a rigidly transformed version of the original pose.

While there is technically a closed form solution for any given skeleton, this is complicated in momentum because different characters attach the rigid parameters to different joints, so a fully general solution uses IK. However, getting it right requires dealing with local minima issues in Euler angles and other challenges. So centralizing this functionality in a single place is useful.

Parameters

[in] ensureContinuousOutput If true, the output model parameters will be solved sequentially so that the resulting output is continuous where possible. This helps to avoid issues with Euler flipping.

Definition at line 229 of file transform_pose.cpp.

References MT_CHECK.

◆ transformPose() [4/6]

template<typename T >

std::vector< ModelParametersT< T > > momentum::transformPose	(	const Character &	character,
		const std::vector< ModelParametersT< T > > &	modelParameters,
		const TransformT< T > &	transforms
	)

Definition at line 78 of file transform_pose.cpp.

References transformPose().

Referenced by transformPose().

◆ transformPose() [5/6]

template std::vector< ModelParametersT< double > > momentum::transformPose	(	const Character &	characterFull,
		const std::vector< ModelParametersT< double > > &	modelParametersFull,
		const std::vector< TransformT< double > > &	transforms,
		bool	ensureContinuousOutput
	)

◆ transformPose() [6/6]

template std::vector< ModelParametersT< float > > momentum::transformPose	(	const Character &	characterFull,
		const std::vector< ModelParametersT< float > > &	modelParametersFull,
		const std::vector< TransformT< float > > &	transforms,
		bool	ensureContinuousOutput
	)

◆ triangulate()

std::vector< Eigen::Vector3i > momentum::triangulate	(	std::span< const uint32_t >	indices,
		std::span< const uint32_t >	offsets
	)

Definition at line 17 of file polygon_data.cpp.

References MT_THROW_IF.

◆ trim() [1/4]

std::string momentum::trim	(	const char *	text,
		const char *	whiteChars = `" \t"`
	)

Returns a copy of the string from which all the characters in whiteChars at the beginning or at the end of the string have been removed.

Parameters

text	The string to trim (null-terminated)
whiteChars	A series of 1-byte characters to remove

Returns: The trimmed string

Definition at line 37 of file string.cpp.

References trim().

◆ trim() [2/4]

template std::string momentum::trim	(	const std::string &	text,
		const char *	whiteChars
	)

◆ trim() [3/4]

template std::string_view momentum::trim	(	const std::string_view &	text,
		const char *	whiteChars
	)

◆ trim() [4/4]

template<typename StringType >

StringType momentum::trim	(	const StringType &	text,
		const char *	whiteChars = `" \t"`
	)

Returns a copy of the string from which all the characters in whiteChars at the beginning or at the end of the string have been removed.

Template Parameters

StringType The type of the string to trim (e.g., std::string, std::string_view)

Parameters

text	The string to trim
whiteChars	A series of 1-byte characters to remove

Returns: The trimmed string

Definition at line 16 of file string.cpp.

Referenced by loadLocatorsFromBuffer(), parseParameterLimits(), parseParameterSets(), parseParameterTransform(), parsePoseConstraints(), tokenize(), tokenize(), and trim().

◆ twopi()

template<typename T = float>

constexpr T momentum::twopi ( )

constexprnoexcept

Definition at line 41 of file constants.h.

◆ uniform() [1/4]

template<typename T >

T momentum::uniform	(	const T &	min,
		const T &	max
	)

Generates a random type T from the uniform distribution, using the global random number generator Random.

Definition at line 322 of file random-inl.h.

References momentum::Random< Generator_ >::GetSingleton().

◆ uniform() [2/4]

template<typename DynamicMatrix >

DynamicMatrix momentum::uniform	(	Eigen::Index	rows,
		Eigen::Index	cols,
		typename DynamicMatrix::Scalar	min,
		typename DynamicMatrix::Scalar	max
	)

Generates a random type dynamic size matrix from the uniform distribution, using the global random number generator Random.

Definition at line 341 of file random-inl.h.

References momentum::Random< Generator_ >::GetSingleton().

◆ uniform() [3/4]

template<typename DynamicVector >

DynamicVector momentum::uniform	(	Eigen::Index	size,
		typename DynamicVector::Scalar	min,
		typename DynamicVector::Scalar	max
	)

Generates a random dynamic size vector from the uniform distribution, using the global random number generator Random.

Definition at line 335 of file random-inl.h.

References momentum::Random< Generator_ >::GetSingleton().

◆ uniform() [4/4]

template<typename FixedSizeT >

FixedSizeT momentum::uniform	(	typename FixedSizeT::Scalar	min,
		typename FixedSizeT::Scalar	max
	)

Generates a random fixed size vector/matrix from the uniform distribution, using the global random number generator Random.

Definition at line 328 of file random-inl.h.

References momentum::Random< Generator_ >::GetSingleton().

◆ uniformAffine3()

template<typename T >

Affine3< T > momentum::uniformAffine3	(	T	scaleMin,
		T	scaleMax,
		const Vector3< T > &	min,
		const Vector3< T > &	max
	)

Generates a random affine transformation from a uniform distribution on the space of all affine transformations.

Definition at line 368 of file random-inl.h.

References momentum::Random< Generator_ >::GetSingleton().

◆ uniformIsometry3()

template<typename T >

Isometry3< T > momentum::uniformIsometry3	(	const Vector3< T > &	min,
		const Vector3< T > &	max
	)

Generates a random isometry (rigid transformation) from a uniform distribution on SE(3) based on input minimum and maximum 3D vectors for the translation part.

Definition at line 362 of file random-inl.h.

References momentum::Random< Generator_ >::GetSingleton().

◆ uniformQuaternion()

template<typename T >

Quaternion< T > momentum::uniformQuaternion ( )

Generates a random quaternion from a uniform distribution on SO(3)

Definition at line 351 of file random-inl.h.

References momentum::Random< Generator_ >::GetSingleton().

◆ uniformRotationMatrix()

template<typename T >

Matrix3< T > momentum::uniformRotationMatrix ( )

Generates a random rotation matrix from a uniform distribution on SO(3)

Definition at line 357 of file random-inl.h.

◆ updateAabb()

template<typename T >

void momentum::updateAabb	(	axel::BoundingBox< T > &	aabb,
		const Vector3< T > &	originA,
		const Vector3< T > &	direction,
		const Vector2< T > &	radii
	)

Updates an axis-aligned bounding box to encompass a tapered capsule.

Parameters

aabb	The bounding box to update
originA	Origin of the capsule
direction	Direction vector of the capsule
radii	Radii at the endpoints of the capsule

Definition at line 112 of file collision_geometry_state.h.

Referenced by momentum::CollisionErrorFunctionT< T >::computeBroadPhase(), momentum::SimdCollisionErrorFunctionT< T >::computeBroadPhase(), logBvh(), momentum::CollisionErrorFunctionT< T >::updateCollisionPairs(), and momentum::SimdCollisionErrorFunctionT< T >::updateCollisionPairs().

◆ validateColumnIndices()

void momentum::validateColumnIndices	(	std::span< const Eigen::Index >	colIndices,
		Eigen::Index	maxEntry
	)

Definition at line 126 of file online_householder_qr.cpp.

References MT_CHECK.

Referenced by momentum::ColumnIndexedMatrix< MatrixType >::ColumnIndexedMatrix().

◆ verticesToFaces()

template<typename T >

std::vector< bool > momentum::verticesToFaces	(	const MeshT< T > &	mesh,
		const std::vector< bool > &	activeVertices
	)

Converts vertex selection to face selection.

Parameters

[in]	character	Character containing the mesh
[in]	activeVertices	Boolean vector indicating which vertices are active

Returns: Boolean vector indicating which faces only contain active vertices

Definition at line 1131 of file character_utility.cpp.

References momentum::MeshT< T >::faces, MT_CHECK, momentum::MeshT< T >::vertices, and verticesToFaces().

Referenced by reduceMeshByVertices(), and verticesToFaces().

◆ verticesToFaces< double >()

template std::vector< bool > momentum::verticesToFaces< double >	(	const MeshT< double > &	mesh,
		const std::vector< bool > &	activeVertices
	)

◆ verticesToFaces< float >()

template std::vector< bool > momentum::verticesToFaces< float >	(	const MeshT< float > &	mesh,
		const std::vector< bool > &	activeVertices
	)

◆ writeModelDefinition()

std::string momentum::writeModelDefinition	(	const Skeleton &	skeleton,
		const ParameterTransform &	parameterTransform,
		const ParameterLimits &	parameterLimits
	)

Write complete model definition file.

Parameters

skeleton	The character's skeletal structure
parameterTransform	Maps model parameters to joint parameters
parameterLimits	Constraints on model parameters (can be empty)

Returns: String containing the complete model definition

Definition at line 656 of file parameter_transform_io.cpp.

References momentum::ParameterTransformT< T >::name, momentum::ParameterTransformT< T >::parameterSets, parameterTransform, momentum::ParameterTransformT< T >::poseConstraints, skeleton, writeParameterLimits(), and writeParameterTransform().

◆ writeParameterLimits()

std::string momentum::writeParameterLimits	(	const ParameterLimits &	parameterLimits,
		const Skeleton &	skeleton,
		const ParameterTransform &	parameterTransform
	)

Definition at line 715 of file parameter_limits_io.cpp.

References Ellipsoid, Extrinsic, HalfPlane, momentum::SkeletonT< T >::joints, kJointParameterNames, kParametersPerJoint, LimitTypeCount, Linear, LinearJoint, MinMax, MinMaxJoint, MinMaxJointPassive, MT_CHECK_LT, momentum::ParameterTransformT< T >::name, parameterTransform, rotationMatrixToEulerXYZ(), skeleton, and toDeg().

Referenced by writeModelDefinition().

◆ writeParameterSets()

std::string momentum::writeParameterSets ( const ParameterSets & parameterSets )

Definition at line 619 of file parameter_transform_io.cpp.

◆ writeParameterTransform()

std::string momentum::writeParameterTransform	(	const ParameterTransform &	parameterTransform,
		const Skeleton &	skeleton
	)

Definition at line 560 of file parameter_transform_io.cpp.

References momentum::ParameterTransformT< T >::activeJointParams, momentum::SkeletonT< T >::joints, kJointParameterNames, kParametersPerJoint, momentum::ParameterTransformT< T >::name, momentum::ParameterTransformT< T >::offsets, parameterTransform, skeleton, and momentum::ParameterTransformT< T >::transform.

Referenced by writeModelDefinition().

◆ writePoseConstraints()

Definition at line 32 of file simd.h.

◆ kAvxPacketSize

constexpr size_t momentum::kAvxPacketSize = 8

inlineconstexpr

Definition at line 31 of file simd.h.

◆ kDefaultExtrapolateFactor

constexpr float momentum::kDefaultExtrapolateFactor = 0.8f

inlineconstexpr

Definition at line 15 of file skeleton_utility.h.

◆ kDefaultExtrapolateMaxDelta

constexpr float momentum::kDefaultExtrapolateMaxDelta = 0.4f

inlineconstexpr

Definition at line 16 of file skeleton_utility.h.

◆ kInvalidIndex

constexpr size_t momentum::kInvalidIndex = std::numeric_limits<size_t>::max()

inlineconstexpr

Definition at line 200 of file types.h.

◆ kInvalidTexCoord

constexpr uint32_t momentum::kInvalidTexCoord = static_cast<uint32_t>(-1)

inlineconstexpr

Definition at line 15 of file polygon_data.cpp.

Referenced by momentum::PolygonData::warnMessage().

◆ kJointParameterNames

constexpr std::array<const char*, kParametersPerJoint> momentum::kJointParameterNames {"tx", "ty", "tz", "rx", "ry", "rz", "sc"}

inlineconstexpr

Definition at line 28 of file types.h.

Referenced by logJointParamNames(), logJointParams(), parameterLimitsFromJson(), parameterLimitsToJson(), parameterTransformFromJson(), parameterTransformToJson(), parseParameterTransform(), writeParameterLimits(), and writeParameterTransform().

◆ kMaxModelParams

constexpr size_t momentum::kMaxModelParams = 2048

◆ kSimdPacketSize

constexpr size_t momentum::kSimdPacketSize = drjit::DefaultSize

inlineconstexpr

Definition at line 34 of file simd.h.

Referenced by momentum::SimdPlaneErrorFunction::getError(), momentum::SimdPositionErrorFunction::getError(), momentum::SimdNormalErrorFunction::getError(), momentum::SimdNormalErrorFunction::getGradient(), momentum::SimdCollisionErrorFunctionT< T >::getGradient(), momentum::SimdCollisionErrorFunctionT< T >::getJacobian(), momentum::SimdNormalErrorFunction::getJacobianSize(), momentum::SimdPlaneErrorFunction::getJacobianSize(), and momentum::SimdPositionErrorFunction::getJacobianSize().

◆ RotationAxis

template<typename T >

const std::array<Vector3<T>, 3> momentum::RotationAxis

Initial value:

= {
    Vector3<T>::UnitX(),
    Vector3<T>::UnitY(),
    Vector3<T>::UnitZ()}

Definition at line 20 of file joint_state.cpp.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Geometry Utilities

Typedef Documentation

◆ Affine3

◆ Affine3d

◆ Affine3f

◆ AimData

◆ AimData_const_p

◆ AimData_const_u

◆ AimData_const_w

◆ AimData_p

◆ AimData_u

◆ AimData_w

◆ AimDatad

◆ AimDatad_const_p

◆ AimDatad_const_u

◆ AimDatad_const_w

◆ AimDatad_p

◆ AimDatad_u

◆ AimDatad_w

◆ AimDirErrorFunction

◆ AimDirErrorFunction_const_p

◆ AimDirErrorFunction_const_u

◆ AimDirErrorFunction_const_w

◆ AimDirErrorFunction_p

◆ AimDirErrorFunction_u

◆ AimDirErrorFunction_w

◆ AimDirErrorFunctiond

◆ AimDirErrorFunctiond_const_p

◆ AimDirErrorFunctiond_const_u

◆ AimDirErrorFunctiond_const_w

◆ AimDirErrorFunctiond_p

◆ AimDirErrorFunctiond_u

◆ AimDirErrorFunctiond_w

◆ AimDistErrorFunction

◆ AimDistErrorFunction_const_p

◆ AimDistErrorFunction_const_u

◆ AimDistErrorFunction_const_w

◆ AimDistErrorFunction_p

◆ AimDistErrorFunction_u

◆ AimDistErrorFunction_w

◆ AimDistErrorFunctiond

◆ AimDistErrorFunctiond_const_p

◆ AimDistErrorFunctiond_const_u

◆ AimDistErrorFunctiond_const_w

◆ AimDistErrorFunctiond_p

◆ AimDistErrorFunctiond_u

◆ AimDistErrorFunctiond_w

◆ AngleAxis

◆ AngleAxisd

◆ AngleAxisf

◆ BlendShape_const_p

◆ BlendShape_const_u

◆ BlendShape_const_w

◆ BlendShape_p

◆ BlendShape_u

◆ BlendShape_w

◆ BlendShapeBase_const_p

◆ BlendShapeBase_const_u

◆ BlendShapeBase_const_w

◆ BlendShapeBase_p

◆ BlendShapeBase_u

◆ BlendShapeBase_w

◆ BlendWeights

◆ BlendWeightsd

◆ Box

◆ Box2

◆ Box2d

◆ Box2f

◆ Box2i

◆ Box3

◆ Box3d

◆ Box3f

◆ Box3i

◆ Boxd